**I just announced the new ***Spring Boot 2* material, coming in REST With Spring:

*Spring Boot 2*material, coming in REST With Spring:

Last modified: November 3, 2018

In this quick tutorial, we’ll show **how to find the point of intersection of two lines defined by the linear functions** in the slope-intercept form.

Any straight line (except vertical) on a plane can be defined by the linear function:

y = mx + b

where *m* is the slope and *b* is the y-intercept.

For a vertical line, *m* would be equal to infinity, that’s why we’re excluding it. If two lines are parallel, they have the same slope, that is the same value of *m*.

Let’s say we have two lines. The first function defines the first line:

y = m1x + b1

And the second function defines the second line:

y = m2x + b2

We want to find the point of intersection of these lines. Obviously, the equation is true for the point of intersection:

y1 = y2

Let’s substitute *y-*variables:

m1x + b1 = m2x + b2

**From the above equation we can find the x-coordinate:**

x(m1 - m2) = b2 - b1 x = (b2 - b1) / (m1 - m2)

**Finally, we can find y-coordinate of the point of intersection:**

y = m1x + b1

Let’s now move on to the implementation part.

Firstly, we have four input variables – *m1, b1* for the first line, and *m2, b2* for the second line.

Secondly, we’ll convert the calculated point of intersection into the object of *java.awt.Point* type.

Finally, lines may be parallel, hence let’s make the returned value *Optional<Point>*:

public Optional<Point> calculateIntersectionPoint( double m1, double b1, double m2, double b2) { if (m1 == m2) { return Optional.empty(); } double x = (b2 - b1) / (m1 - m2); double y = m1 * x + b1; Point point = new Point(); point.setLocation(x, y); return Optional.of(point); }

Now let’s choose some values and test the method for parallel and non-parallel lines.

For example, let’s take the *x*-axis (*y = 0*) as the first line, and the line defined by *y = x – 1 *as the second line.

For the second line, the slope *m* is equal to *1* which means *45* degrees, and the* y*-intercept is equal to *-1 *which means that the line intercepts the *y*-axis in the point (0, -1).

It’s intuitively clear that the point of intersection of the second line with the *x*-axis must be *(1,0*):

Let’s check it.

Firstly, let’s make sure that a *Point* is present, as the lines aren’t parallel, and then check the values of *x* and *y*:

@Test public void givenNotParallelLines_whenCalculatePoint_thenPresent() { double m1 = 0; double b1 = 0; double m2 = 1; double b2 = -1; Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2); assertTrue(point.isPresent()); assertEquals(point.get().getX(), 1, 0.001); assertEquals(point.get().getY(), 0, 0.001); }

Lastly, let’s take two parallel lines and make sure that the returned value is empty:

@Test public void givenParallelLines_whenCalculatePoint_thenEmpty() { double m1 = 1; double b1 = 0; double m2 = 1; double b2 = -1; Optional<Point> point = service.calculateIntersectionPoint(m1, b1, m2, b2); assertFalse(point.isPresent()); }

In this tutorial, we’ve shown how to calculate the point of intersection of two lines.

As usual, the complete source code is available over on GitHub.