Hoey algorithm apply this principle to solve the line segment intersection detection problem, as stated above, of determine whether or not a set of line sections has an intersection; the Bentley – Ottmann algorithm works by the same principle to list all intersections in logarithmic time per intersection. The most common, and more efficient, way to solve this problem for a high number of sections is to use a sweep line algorithm, where we imagine a line sliding across the line sections and we track

COMING SOON!

```
/**
* @file
* @brief check whether two line segments intersect each other
* or not.
*/
#include <iostream>
/**
* Define a Point.
*/
struct Point {
int x; /// Point respect to x coordinate
int y; /// Point respect to y coordinate
};
/**
* intersect returns true if segments of two line intersects and
* false if they do not. It calls the subroutines direction
* which computes the orientation.
*/
struct SegmentIntersection {
inline bool intersect(Point first_point, Point second_point,
Point third_point, Point forth_point) {
int direction1 = direction(third_point, forth_point, first_point);
int direction2 = direction(third_point, forth_point, second_point);
int direction3 = direction(first_point, second_point, third_point);
int direction4 = direction(first_point, second_point, forth_point);
if ((direction1 < 0 || direction2 > 0) && (direction3 < 0 ||
direction4 > 0))
return true;
else if (direction1 == 0 && on_segment(third_point, forth_point,
first_point))
return true;
else if (direction2 == 0 && on_segment(third_point, forth_point,
second_point))
return true;
else if (direction3 == 0 && on_segment(first_point, second_point,
third_point))
return true;
else if (direction3 == 0 && on_segment(first_point, second_point,
forth_point))
return true;
else
return false;
}
/**
* We will find direction of line here respect to @first_point.
* Here @second_point and @third_point is first and second points
* of the line respectively. we want a method to determine which way a
* given angle these three points turns. If returned number is negative,
* then the angle is counter-clockwise. That means the line is going to
* right to left. We will fount angle as clockwise if the method returns
* positive number.
*/
inline int direction(Point first_point, Point second_point,
Point third_point) {
return ((third_point.x-first_point.x)*(second_point.y-first_point.y))-
((second_point.x-first_point.x) * (third_point.y-first_point.y));
}
/**
* This method determines whether a point known to be colinear
* with a segment lies on that segment.
*/
inline bool on_segment(Point first_point, Point second_point,
Point third_point) {
if (std::min(first_point.x, second_point.x) <= third_point.x &&
third_point.x <= std::max(first_point.x, second_point.x) &&
std::min(first_point.y, second_point.y) <= third_point.y &&
third_point.y <= std::max(first_point.y, second_point.y))
return true;
else
return false;
}
};
/**
* This is the main function to test whether the algorithm is
* working well.
*/
int main() {
SegmentIntersection segment;
Point first_point, second_point, third_point, forth_point;
std::cin >> first_point.x >> first_point.y;
std::cin >> second_point.x >> second_point.y;
std::cin >> third_point.x >> third_point.y;
std::cin >> forth_point.x >> forth_point.y;
printf("%d", segment.intersect(first_point, second_point, third_point,
forth_point));
std::cout << std::endl;
}
```