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++ program for point clipping Algorithm  #include <bits/stdc++.h>  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<n; i++)   {   if ( (XY[i][0] >= 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] <<","<<XY[i][1]<<"] ";   }   }   // print point coordinate outside viewing pane   cout<<"\n"<< endl;  cout << "Point outside the viewing pane:"<<endl;   for (int i = 0; i < n; i++)   {   if ((XY[i][0] < Xmin) || (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 program for point clipping Algorithm #include<stdio.h> //#include<graphics.h> // 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<n; i++)  {  if ( (XY[i][0] >= 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<n; i++)  {  if ((XY[i][0] >= 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<n; i++)  {  if ((XY[i][0] < Xmin) || (XY[i][0] > 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 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<n; i++)  {  if ( (XY[i][0] >= 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<n; i++)  {  if ((XY[i][0] < Xmin) || (XY[i][0] > 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 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<n i++)     if ((XY[i][0] >= 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# 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<n; i++)  {  if ( (XY[i,0] >= 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 

// 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

Advantages :
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.

Dis-Advantages :

There are also some disadvantages, including:

1. Limited to 2D: The algorithm is designed to work in two dimensions, and it may not be suitable for handling objects in three-dimensional space. This can limit its usefulness in some applications, such as 3D modeling and virtual reality.
2. Complexity: Some variants of the algorithm, such as the Cyrus-Beck algorithm, can be relatively complex and require a significant amount of computational resources to execute. This can make them less efficient than other algorithms, particularly for large or complex objects.
3. Precision Issues: The algorithm can suffer from precision issues, particularly when dealing with objects that are very small or have complex shapes. This can result in clipping errors or inaccuracies in the rendered image.
4. Performance: Although the algorithm is relatively efficient, it can still have a significant impact on the performance of a computer graphics application, particularly if it is used to clip a large number of objects.
5. Limitations: The algorithm is limited in its ability to handle certain types of objects or regions. For example, it may not be suitable for handling objects with concave shapes or regions that are defined by curved boundaries.