Related Articles

# Coplanarity of Two Lines in 3D Geometry

• Last Updated : 10 May, 2021

Given two lines L1 and L2, each passing through a point whose position vector are given as (X, Y, Z) and parallel to line whose direction ratios are given as (a, b, c), the task is to check whether line L1 and L2 are coplanar or not.

Coplanar: If two lines are in a same plane then lines can be called as coplanar.

Example:

Input:
L1: (x1, y1, z1) = (-3, 1, 5) and (a1, b1, c1) = (-3, 1, 5)
L2: (x1, y1, z1) = (-1, 2, 5) and (a1, b1, c1) = (-1, 2, 5)
Output: Lines are Coplanar

Input:
L1: (x1, y1, z1) = (1, 2, 3) and (a1, b1, c1) = (2, 4, 6)
L2: (x1, y1, z1) = (-1, -2, -3) and (a1, b1, c1) = (3, 4, 5)
Output: Lines are Non-Coplanar

Approach:

There are two ways to express a line in 3 dimensions:

Vector Form:
The equation of two lines whose coplanarity is to be determined in vector form.

In the above equation of a line, a vector is a point in the 3D plane from which a given line is passing through called as position vector a and b vector is the vector line in the 3D plane to which our given line is parallel. So it can be said that the line(1) passes through the point, say A, with position vector a1 and is parallel to vector b1 and the line(2) passes through the point, say B with position vector a2 and is parallel to vector b2. Therefore:

The given lines are coplanar if and only if AB vector is perpendicular to the cross product of vectors b1 and b2 i.e.,

Here the cross product of vectors b1 and b2 will give another vector line that will be perpendicular to both b1 and b2 vector lines. and AB is the line vector joining the position vectors a1 and a2 of two given lines.  Now, check whether two lines are coplanar or not by determining above dot product is zero or not.

Cartesian Form:
Let (x1, y1, z1) and (x2, y2, z2) be the coordinates of points A and B respectively.
Let a1, b1, c1, and a2, b2, c2 be the direction ratios of vectors b1 and  b2 respectively. Then

The given lines are coplanar if and only if:

In Cartesian Form it can be expressed as:

Therefore, for both type of forms needs a position vector a1 and a2 in input as (x1, y1, z1) and (x2, y2, z2) respectively and direction ratios of vectors b1 and b2 as (a1, b1, c1) and (a2, b2, c2) respectively.
Follow the steps below to solve the problem:

• Initialize a 3 X 3 matrix to store the elements of the Determinant shown above.
• Calculate the cross product of b2 and b1 and the dot product of (a2 – a1).
• If the value of the Determinant is 0, the lines are coplanar. Otherwise, they are non-coplanar.

Below is the implementation of the above approach:

## C++

 `// C++ program implement``// the above approach``#include ``using` `namespace` `std;` `// Function to generate determinant``int` `det(``int` `d[][3])``{``    ``int` `Sum = d[0][0] * ((d[1][1] * d[2][2]) - (d[2][1] * d[1][2]));``    ``Sum -= d[0][1] * ((d[1][0] * d[2][2]) -  (d[1][2] * d[2][0]));``    ``Sum += d[0][2] * ((d[0][1] * d[1][2]) -(d[0][2] * d[1][1]));``    ` `    ``// Return the sum``    ``return` `Sum;``}` `// Driver Code``int` `main()``{``    ``// Position vector of first line``    ``int` `x1 = -3, y1 = 1, z1 = 5; ``    ` `    ``// Direction ratios of line to``    ``// which first line is parallel``    ``int` `a1 = -3, b1 = 1, c1 = 5;``    ` `    ``// Position vectors of second line``    ``int` `x2 = -1, y2 = 2, z2 = 5; ``    ` `    ``// Direction ratios of line to``    ``// which second line is parallel``    ``int` `a2 = -1, b2 = 2, c2 = 5;``    ` `    ``// Determinant to check coplanarity``    ``int` `det_list[3][3] = { {x2 - x1, y2 - y1, z2 - z1}, ``                          ``{a1, b1, c1}, {a2, b2, c2}};``     ` `     ``// If determinant is zero``    ``if``(det(det_list) == 0)``    ``{``        ``cout << ``"Lines are coplanar"` `<< endl;``    ``}``  ` `    ``// Otherwise``    ``else``    ``{``        ``cout << ``"Lines are non coplanar"` `<< endl;``    ``}``   ``return` `0;``}` `// This code is contributed by avanitrachhadiya2155`

## Java

 `// Java program implement``// the above approach``import` `java.io.*;` `class` `GFG{``    ` `// Function to generate determinant``static` `int` `det(``int``[][] d)``{``    ``int` `Sum = d[``0``][``0``] * ((d[``1``][``1``] * d[``2``][``2``]) -``                         ``(d[``2``][``1``] * d[``1``][``2``]));``    ``Sum -= d[``0``][``1``] * ((d[``1``][``0``] * d[``2``][``2``]) -``                      ``(d[``1``][``2``] * d[``2``][``0``]));``    ``Sum += d[``0``][``2``] * ((d[``0``][``1``] * d[``1``][``2``]) -``                      ``(d[``0``][``2``] * d[``1``][``1``]));` `    ``// Return the sum``    ``return` `Sum;``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Position vector of first line``    ``int` `x1 = -``3``, y1 = ``1``, z1 = ``5``;` `    ``// Direction ratios of line to``    ``// which first line is parallel``    ``int` `a1 = -``3``, b1 = ``1``, c1 = ``5``;``    ` `    ``// Position vectors of second line``    ``int` `x2 = -``1``, y2 = ``2``, z2 = ``5``;``    ` `    ``// Direction ratios of line to``    ``// which second line is parallel``    ``int` `a2 = -``1``, b2 = ``2``, c2 = ``5``;``    ` `    ``// Determinant to check coplanarity``    ``int``[][] det_list = { {x2 - x1, y2 - y1, z2 - z1},``                         ``{a1, b1, c1}, {a2, b2, c2}};` `    ``// If determinant is zero``    ``if``(det(det_list) == ``0``)``        ``System.out.print(``"Lines are coplanar"``);` `    ``// Otherwise``    ``else``        ``System.out.print(``"Lines are non coplanar"``);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python Program implement``# the above approach` `# Function to generate determinant``def` `det(d):``    ``Sum` `=` `d[``0``][``0``] ``*` `((d[``1``][``1``] ``*` `d[``2``][``2``])``                    ``-` `(d[``2``][``1``] ``*` `d[``1``][``2``]))``    ``Sum` `-``=` `d[``0``][``1``] ``*` `((d[``1``][``0``] ``*` `d[``2``][``2``])``                    ``-` `(d[``1``][``2``] ``*` `d[``2``][``0``]))``    ``Sum` `+``=` `d[``0``][``2``] ``*` `((d[``0``][``1``] ``*` `d[``1``][``2``])``                    ``-` `(d[``0``][``2``] ``*` `d[``1``][``1``]))` `    ``# Return the sum``    ``return` `Sum` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Position vector of first line``    ``x1, y1, z1 ``=` `-``3``, ``1``, ``5` `    ``# Direction ratios of line to``    ``# which first line is parallel``    ``a1, b1, c1 ``=` `-``3``, ``1``, ``5` `    ``# Position vectors of second line``    ``x2, y2, z2 ``=` `-``1``, ``2``, ``5` `    ``# Direction ratios of line to``    ``# which second line is parallel``    ``a2, b2, c2 ``=` `-``1``, ``2``, ``5` `    ``# Determinant to check coplanarity``    ``det_list ``=` `[[x2``-``x1, y2``-``y1, z2``-``z1],``                ``[a1, b1, c1], [a2, b2, c2]]` `    ``# If determinant is zero``    ``if``(det(det_list) ``=``=` `0``):``        ``print``(``"Lines are coplanar"``)` `    ``# Otherwise``    ``else``:``        ``print``(``"Lines are non coplanar"``)`

## C#

 `// C# program implement``// the above approach``using` `System;` `class` `GFG{` `// Function to generate determinant``static` `int` `det(``int``[,] d)``{``    ``int` `Sum = d[0, 0] * ((d[1, 1] * d[2, 2]) -``                         ``(d[2, 1] * d[1, 2]));``    ``Sum -= d[0, 1] * ((d[1, 0] * d[2, 2]) -``                      ``(d[1, 2] * d[2, 0]));``    ``Sum += d[0, 2] * ((d[0, 1] * d[1, 2]) -``                      ``(d[0, 2] * d[1, 1]));` `    ``// Return the sum``    ``return` `Sum;``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Position vector of first line``    ``int` `x1 = -3, y1 = 1, z1 = 5;` `    ``// Direction ratios of line to``    ``// which first line is parallel``    ``int` `a1 = -3, b1 = 1, c1 = 5;``    ` `    ``// Position vectors of second line``    ``int` `x2 = -1, y2 = 2, z2 = 5;``    ` `    ``// Direction ratios of line to``    ``// which second line is parallel``    ``int` `a2 = -1, b2 = 2, c2 = 5;``    ` `    ``// Determinant to check coplanarity``    ``int``[,] det_list = { {x2 - x1, y2 - y1, z2 - z1},``                        ``{a1, b1, c1}, {a2, b2, c2}};` `    ``// If determinant is zero``    ``if` `(det(det_list) == 0)``        ``Console.Write(``"Lines are coplanar"``);` `    ``// Otherwise``    ``else``        ``Console.Write(``"Lines are non coplanar"``);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``
Output:
`Lines are coplanar`

Time Complexity: O(1)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up