# How to check if a given point lies inside or outside a polygon?

• Difficulty Level : Hard
• Last Updated : 14 Oct, 2022

Given a polygon and a point ‘p‘, find if ‘p‘ lies inside the polygon or not. The points lying on the border are considered inside.

Examples:

Approach: The idea to solve this problem is based on How to check if two given line segments intersect, and to be used as follows:

1. Draw a horizontal line to the right of each point and extend it to infinity
2. Count the number of times the line intersects with polygon edges.
3. A point is inside the polygon if either count of intersections is odd or point lies on an edge of polygon.  If none of the conditions is true, then point lies outside.

How to handle point ‘g’ in the above figure?

Note that we should return true if the point lies on the line or the same as one of the vertices of the given polygon. To handle this, after checking if the line from ‘p’ to extreme intersects, we check whether ‘p’ is collinear with vertices of the current line of polygon. If it is collinear, then we check if the point ‘p’ lies on current side of polygon, if it lies, we return true, else false.

Following is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `struct` `Point {``    ``int` `x, y;``};` `struct` `line {``    ``Point p1, p2;``};` `bool` `onLine(line l1, Point p)``{``    ``// Check whether p is on the line or not``    ``if` `(p.x <= max(l1.p1.x, l1.p2.x)``        ``&& p.x <= min(l1.p1.x, l1.p2.x)``        ``&& (p.y <= max(l1.p1.y, l1.p2.y)``            ``&& p.y <= min(l1.p1.y, l1.p2.y)))``        ``return` `true``;` `    ``return` `false``;``}` `int` `direction(Point a, Point b, Point c)``{``    ``int` `val = (b.y - a.y) * (c.x - b.x)``              ``- (b.x - a.x) * (c.y - b.y);` `    ``if` `(val == 0)` `        ``// Colinear``        ``return` `0;` `    ``else` `if` `(val < 0)` `        ``// Anti-clockwise direction``        ``return` `2;` `    ``// Clockwise direction``    ``return` `1;``}` `bool` `isIntersect(line l1, line l2)``{``    ``// Four direction for two lines and points of other line``    ``int` `dir1 = direction(l1.p1, l1.p2, l2.p1);``    ``int` `dir2 = direction(l1.p1, l1.p2, l2.p2);``    ``int` `dir3 = direction(l2.p1, l2.p2, l1.p1);``    ``int` `dir4 = direction(l2.p1, l2.p2, l1.p2);` `    ``// When intersecting``    ``if` `(dir1 != dir2 && dir3 != dir4)``        ``return` `true``;` `    ``// When p2 of line2 are on the line1``    ``if` `(dir1 == 0 && onLine(l1, l2.p1))``        ``return` `true``;` `    ``// When p1 of line2 are on the line1``    ``if` `(dir2 == 0 && onLine(l1, l2.p2))``        ``return` `true``;` `    ``// When p2 of line1 are on the line2``    ``if` `(dir3 == 0 && onLine(l2, l1.p1))``        ``return` `true``;` `    ``// When p1 of line1 are on the line2``    ``if` `(dir4 == 0 && onLine(l2, l1.p2))``        ``return` `true``;` `    ``return` `false``;``}` `bool` `checkInside(Point poly[], ``int` `n, Point p)``{` `    ``// When polygon has less than 3 edge, it is not polygon``    ``if` `(n < 3)``        ``return` `false``;` `    ``// Create a point at infinity, y is same as point p``    ``line exline = { p, { 9999, p.y } };``    ``int` `count = 0;``    ``int` `i = 0;``    ``do` `{` `        ``// Forming a line from two consecutive points of``        ``// poly``        ``line side = { poly[i], poly[(i + 1) % n] };``        ``if` `(isIntersect(side, exline)) {` `            ``// If side is intersects exline``            ``if` `(direction(side.p1, p, side.p2) == 0)``                ``return` `onLine(side, p);``            ``count++;``        ``}``        ``i = (i + 1) % n;``    ``} ``while` `(i != 0);` `    ``// When count is odd``    ``return` `count & 1;``}` `// Driver code``int` `main()``{``    ``Point polygon[]``        ``= { { 0, 0 }, { 10, 0 }, { 10, 10 }, { 0, 10 } };``    ``Point p = { 5, 3 };``    ``int` `n = 4;` `    ``// Function call``    ``if` `(checkInside(polygon, n, p))``        ``cout << ``"Point is inside."``;``    ``else``        ``cout << ``"Point is outside."``;``  ` `    ``return` `0;``}`

Output

`Point is inside.`

Time Complexity: O(n) where n is the number of vertices in the given polygon.
Auxiliary Space: O(1), since no extra space has been taken.