Open In App
Related Articles

# Point Clipping Algorithm in Computer Graphics

The Point Clipping Algorithm is a fundamental algorithm used in Computer Graphics to determine whether a point lies inside or outside a specific region or boundary. It is particularly useful when dealing with objects that have complex shapes or when displaying only a portion of an image.

Clipping: In computer graphics our screen act as a 2-D coordinate system. it is not necessary that each and every point can be viewed on our viewing pane(i.e. our computer screen). We can view points, which lie in particular range (0,0) and (Xmax, Ymax). So, clipping is a procedure that identifies those portions of a picture that are either inside or outside of our viewing pane.
In case of point clipping, we only show/print points on our window which are in range of our viewing pane, others points which are outside the range are discarded.
Example

```Input :

Output :```

Point Clipping Algorithm:

1. Get the minimum and maximum coordinates of both viewing pane.
2. Get the coordinates for a point.
3. Check whether given input lies between minimum and maximum coordinate of viewing pane.
4. If yes display the point which lies inside the region otherwise discard it.

## C++

 `// C++ program for point clipping Algorithm ``#include  ``using` `namespace` `std;`` ` `// Function for point clipping ``void` `pointClip(``int` `XY[][2], ``int` `n, ``int` `Xmin, ``int` `Ymin, ``                                ``int` `Xmax, ``int` `Ymax) ``{ ``    ``/*************** Code for graphics view ``    ``// initialize graphics mode ``    ``detectgraph(&gm,&gr); ``    ``initgraph(&gm,&gr,"d:\\tc\\BGI"); ``    ``for (int i=0; i= Xmin) && (XY[i][0] <= Xmax)) ``    ``{ ``            ``if ( (XY[i][1] >= Ymin) && (XY[i][1] <= Ymax)) ``        ``putpixel(XY[i][0],XY[i][1],3); ``    ``} ``    ``} ``    ``**********************/``    ``/**** Arithmetic view ****/``    ``cout << ``"Point inside the viewing pane:"` `<< endl; ``    ``for` `(``int` `i = 0; i < n; i++) ``    ``{ ``        ``if` `((XY[i][0] >= Xmin) && (XY[i][0] <= Xmax)) ``        ``{ ``            ``if` `((XY[i][1] >= Ymin) && (XY[i][1] <= Ymax)) ``                ``cout <<``"["` `<< XY[i][0] <<``","``< Xmax)) ``            ``cout << ``"["` `<< XY[i][0] << ``","` `<< XY[i][1] << ``"] "``;``        ``if` `((XY[i][1] < Ymin) || (XY[i][1] > Ymax)) ``            ``cout << ``"["` `<< XY[i][0] << ``","` `<< XY[i][1] << ``"] "``;``    ``} ``} `` ` `// Driver code ``int` `main() ``{ ``    ``int` `XY[6][2] = {{10, 10}, {-10, 10}, {400, 100}, ``                    ``{100, 400}, {400, 400}, {100, 40}}; `` ` `    ``// getmaxx() & getmaxy() will return Xmax, Ymax ``    ``// value if graphics.h is included ``    ``int` `Xmin = 0; ``    ``int` `Xmax = 350; ``    ``int` `Ymin = 0; ``    ``int` `Ymax = 350; ``    ``pointClip(XY, 6, Xmin, Ymin, Xmax, Ymax); ``    ``return` `0; ``} `` ` `// This code is contributed by SHUBHAMSINGH10`

## C

 `// C program for point clipping Algorithm``#include``//#include`` ` `// Function for point clipping``void` `pointClip(``int` `XY[][2], ``int` `n, ``int` `Xmin, ``int` `Ymin,``                                   ``int` `Xmax, ``int` `Ymax)``{``    ``/*************** Code for graphics view``    ``// initialize graphics mode``    ``detectgraph(&gm,&gr);``    ``initgraph(&gm,&gr,"d:\\tc\\BGI");``    ``for (int i=0; i= Xmin) && (XY[i][0] <= Xmax))``    ``{``            ``if ( (XY[i][1] >= Ymin) && (XY[i][1] <= Ymax))``        ``putpixel(XY[i][0],XY[i][1],3);``    ``}``    ``}``    ``**********************/``    ``/**** Arithmetic view ****/``    ``printf` `(``"Point inside the viewing pane:\n"``);``    ``for` `(``int` `i=0; i= Xmin) && (XY[i][0] <= Xmax))``        ``{``            ``if` `((XY[i][1] >= Ymin) && (XY[i][1] <= Ymax))``                ``printf` `(``"[%d, %d] "``, XY[i][0], XY[i][1]);``        ``}``    ``}`` ` `    ``// print point coordinate outside viewing pane``    ``printf` `(``"\nPoint outside the viewing pane:\n"``);``    ``for` `(``int` `i=0; i Xmax))``            ``printf` `(``"[%d, %d] "``, XY[i][0], XY[i][1]);``        ``if` `((XY[i][1] < Ymin) || (XY[i][1] > Ymax))``            ``printf` `(``"[%d, %d] "``, XY[i][0], XY[i][1]);``    ``}``}`` ` `// Driver code``int` `main()``{``    ``int` `XY[6][2] = {{10,10}, {-10,10}, {400,100},``                    ``{100,400}, {400,400}, {100,40}};`` ` `    ``// getmaxx() & getmaxy() will return Xmax, Ymax``    ``// value if graphics.h is included``    ``int` `Xmin = 0;``    ``int` `Xmax = 350;``    ``int` `Ymin = 0;``    ``int` `Ymax = 350;``    ``pointClip(XY, 6,  Xmin, Ymin, Xmax, Ymax);``    ``return` `0;``}`

## Java

 `// Java program for point clipping Algorithm``class` `GFG ``{`` ` `// Function for point clipping``static` `void` `pointClip(``int` `XY[][], ``int` `n, ``                        ``int` `Xmin, ``int` `Ymin,``                        ``int` `Xmax, ``int` `Ymax)``{``    ``/*************** Code for graphics view``    ``// initialize graphics mode``    ``detectgraph(&gm,&gr);``    ``initgraph(&gm,&gr,"d:\\tc\\BGI");``    ``for (int i=0; i= Xmin) && (XY[i][0] <= Xmax))``    ``{``            ``if ( (XY[i][1] >= Ymin) && (XY[i][1] <= Ymax))``        ``putpixel(XY[i][0],XY[i][1],3);``    ``}``    ``}``    ``**********************/``    ``/**** Arithmetic view ****/``    ``System.out.printf (``"Point inside the viewing pane:\n"``);``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `((XY[i][``0``] >= Xmin) && (XY[i][``0``] <= Xmax))``        ``{``            ``if` `((XY[i][``1``] >= Ymin) && (XY[i][``1``] <= Ymax))``                ``System.out.printf (``"[%d, %d] "``, XY[i][``0``], XY[i][``1``]);``        ``}``    ``}`` ` `    ``// print point coordinate outside viewing pane``    ``System.out.printf (``"\nPoint outside the viewing pane:\n"``);``    ``for` `(``int` `i=``0``; i Xmax))``            ``System.out.printf (``"[%d, %d] "``, XY[i][``0``], XY[i][``1``]);``        ``if` `((XY[i][``1``] < Ymin) || (XY[i][``1``] > Ymax))``            ``System.out.printf (``"[%d, %d] "``, XY[i][``0``], XY[i][``1``]);``    ``}``}`` ` `// Driver code``public` `static` `void` `main(String[] args) ``{``        ``int` `XY[][] = {{``10``,``10``}, {-``10``,``10``}, {``400``,``100``},``                    ``{``100``,``400``}, {``400``,``400``}, {``100``,``40``}};`` ` `    ``// getmaxx() & getmaxy() will return Xmax, Ymax``    ``// value if graphics.h is included``    ``int` `Xmin = ``0``;``    ``int` `Xmax = ``350``;``    ``int` `Ymin = ``0``;``    ``int` `Ymax = ``350``;``    ``pointClip(XY, ``6``, Xmin, Ymin, Xmax, Ymax);``}``}`` ` `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python3 program for point clipping Algorithm`` ` `# Function for point clipping ``def` `pointClip(XY, n, Xmin, Ymin, Xmax, Ymax):`` ` `    ``"""************** Code for graphics view ``    ``# initialize graphics mode ``    ``detectgraph(&gm, &gr) ``    ``initgraph(&gm, &gr, "d:\\tc\\BGI") ``    ``for (i=0 i= Xmin) and ``        ``(XY[i][0] <= Xmax)) ``     ` `        ``if ((XY[i][1] >= Ymin) and ``            ``(XY[i][1] <= Ymax)) ``        ``putpixel(XY[i][0], XY[i][1], 3) ``     ` `    ``*********************"""``    ``"""*** Arithmetic view ***"""``    ``print``(``"Point inside the viewing pane:"``) ``    ``for` `i ``in` `range``(n):``        ``if` `((XY[i][``0``] >``=` `Xmin) ``and` `            ``(XY[i][``0``] <``=` `Xmax)): ``            ``if` `((XY[i][``1``] >``=` `Ymin) ``and` `                ``(XY[i][``1``] <``=` `Ymax)): ``                ``print``(``"["``, XY[i][``0``], ``", "``, XY[i][``1``], ``                      ``"]"``, sep ``=` `"``", end = "` `") ``         ` `    ``# prpocoordinate outside viewing pane ``    ``print``(``"\n\nPoint outside the viewing pane:"``) ``    ``for` `i ``in` `range``(n):     ``        ``if` `((XY[i][``0``] < Xmin) ``or` `(XY[i][``0``] > Xmax)) :``            ``print``(``"["``, XY[i][``0``], ``", "``, XY[i][``1``],``                  ``"]"``, sep ``=` `"``", end = "` `") ``        ``if` `((XY[i][``1``] < Ymin) ``or` `(XY[i][``1``] > Ymax)) :``            ``print``(``"["``, XY[i][``0``], ``", "``, XY[i][``1``], ``                  ``"]"``, sep ``=` `"``", end = "` `") `` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``XY ``=` `[[``10``, ``10``], [``-``10``, ``10``], [``400``, ``100``], ``          ``[``100``, ``400``], [``400``, ``400``], [``100``, ``40``]] `` ` `    ``# getmaxx() & getmaxy() will return Xmax, ``    ``# Ymax value if graphics.h is included ``    ``Xmin ``=` `0``    ``Xmax ``=` `350``    ``Ymin ``=` `0``    ``Ymax ``=` `350``    ``pointClip(XY, ``6``, Xmin, Ymin, Xmax, Ymax)`` ` `# This code is contributed by``# SHUBHAMSINGH10`

## C#

 `// C# program for point clipping Algorithm``using` `System;`` ` `class` `GFG ``{`` ` `// Function for point clipping``static` `void` `pointClip(``int` `[,]XY, ``int` `n, ``                        ``int` `Xmin, ``int` `Ymin,``                        ``int` `Xmax, ``int` `Ymax)``{``    ``/*************** Code for graphics view``    ``// initialize graphics mode``    ``detectgraph(&gm,&gr);``    ``initgraph(&gm,&gr,"d:\\tc\\BGI");``    ``for (int i=0; i= Xmin) && (XY[i,0] <= Xmax))``    ``{``            ``if ( (XY[i,1] >= Ymin) && (XY[i,1] <= Ymax))``        ``putpixel(XY[i,0],XY[i,1],3);``    ``}``    ``}``    ``**********************/``    ``/**** Arithmetic view ****/``    ``Console.Write(``"Point inside the viewing pane:\n"``);``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `((XY[i, 0] >= Xmin) && (XY[i, 0] <= Xmax))``        ``{``            ``if` `((XY[i, 1] >= Ymin) && (XY[i, 1] <= Ymax))``                ``Console.Write(``"[{0}, {1}] "``, XY[i, 0], XY[i, 1]);``        ``}``    ``}`` ` `    ``// print point coordinate outside viewing pane``    ``Console.Write(``"\nPoint outside the viewing pane:\n"``);``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `((XY[i, 0] < Xmin) || (XY[i, 0] > Xmax))``            ``Console.Write(``"[{0}, {1}] "``, XY[i, 0], XY[i, 1]);``        ``if` `((XY[i, 1] < Ymin) || (XY[i, 1] > Ymax))``            ``Console.Write(``"[{0}, {1}] "``, XY[i, 0], XY[i, 1]);``    ``}``}`` ` `// Driver code``public` `static` `void` `Main(String[] args) ``{``        ``int` `[,]XY = {{10, 10}, {-10, 10}, {400, 100},``                    ``{100, 400}, {400, 400}, {100, 40}};`` ` `    ``// getmaxx() & getmaxy() will return Xmax, Ymax``    ``// value if graphics.h is included``    ``int` `Xmin = 0;``    ``int` `Xmax = 350;``    ``int` `Ymin = 0;``    ``int` `Ymax = 350;``    ``pointClip(XY, 6, Xmin, Ymin, Xmax, Ymax);``}``}`` ` `// This code contributed by Rajput-Ji`

## Javascript

 `// JS code``const pointClip = (XY, n, Xmin, Ymin, Xmax, Ymax) => {``    ``console.log(``"Point inside the viewing pane:"``);``    ``for` `(let i = 0; i < n; i++) {``        ``if` `((XY[i][0] >= Xmin) && (XY[i][0] <= Xmax)) {``            ``if` `((XY[i][1] >= Ymin) && (XY[i][1] <= Ymax))``                ``console.log(`[\${XY[i][0]},\${XY[i][1]}]`);``        ``}``    ``}`` ` `    ``// print point coordinate outside viewing pane ``    ``console.log(``"\nPoint outside the viewing pane:"``);``    ``for` `(let i = 0; i < n; i++) {``        ``if` `((XY[i][0] < Xmin) || (XY[i][0] > Xmax))``            ``console.log(`[\${XY[i][0]},\${XY[i][1]}]`);``        ``if` `((XY[i][1] < Ymin) || (XY[i][1] > Ymax))``            ``console.log(`[\${XY[i][0]},\${XY[i][1]}]`);``    ``}``};`` ` `// Driver code `` ` `    ``let XY = [[10, 10], [-10, 10], [400, 100], [100, 400], [400, 400], [100, 40]];``    ``let Xmin = 0;``    ``let Xmax = 350;``    ``let Ymin = 0;``    ``let Ymax = 350;``    ``pointClip(XY, 6, Xmin, Ymin, Xmax, Ymax);`` ` `// This code is contributed by ishankhandelwals.`

Output:

```Point inside the viewing pane:
[10, 10] [100, 40]

Point outside the viewing pane:
[-10, 10] [400, 100] [100, 400] [400, 400] [400, 400] ```

Time Complexity: O(N)
Auxiliary Space: O(1)
Related Post :
Line Clipping | Set 1 (Cohen–Sutherland Algorithm)
Polygon Clipping | Sutherland–Hodgman Algorithm

The Point Clipping Algorithm has several advantages in computer graphics, including:

1. Versatility: The algorithm can be applied to a wide range of objects, including points, lines, polygons, and other complex shapes. This makes it a versatile tool for a wide range of applications.
2. Efficiency: The algorithm is relatively efficient and can be used to quickly identify and remove points that lie outside a specified region or boundary. This can help improve the performance of computer graphics applications, particularly those that involve rendering large or complex scenes.
3. Accuracy: The Point Clipping Algorithm can be used to accurately clip objects and ensure that only the portions of an object that are visible or relevant are displayed. This can help improve the visual quality of images and animations.
4. Flexibility: The algorithm can be easily adapted to different applications and scenarios. For example, different variants of the algorithm can be used to clip points, lines, and polygons, and to handle different types of regions and boundaries.
5. Ease of Implementation: The algorithm is relatively straightforward to implement and can be integrated into computer graphics applications with minimal effort. This makes it an attractive option for developers who want to add clipping functionality to their applications.