Cylinder and Cylinder Intersection

Intro

Exploring Cylinder to Cylinder intersection. Primarily interested in whether or not a collision between two cylinders has occurred. So the intersecting surface does not need to be found.

Let the cylinders generally be finite - fixed in length. This does not stop discussing the infinite cylinders case as that is the simpler situation.

Disk and Disk intersections can be computed in constant time. This is used by the cylinder and cylinder intersection algorithms.

Brute Force

This actually may be the best method. Express the cylinders as vector equations. Get a really good general purpose numerical equations optimizer. Then minimize the two points with a fixed number of iterations. If the distance between the two points is below a threshold then intersection has occurred.

Describe a cylinder.

Cylinder surface $C1 (t_{1}, θ_{1})$
Solid Cylinder $C1 (t_{1}, θ_{1}, r_{1})$

Solve the equations.

Minimize $distance (C1 - C2)$

An initial point may be minimizing a point on the lines along the cylinders axes, capping the points so they are within the cylinder.

This is either a 4 variable problem with non-linear equations or a 6 variable problem with non-linear equations.

I do not know which will perform better as I have not implemented these.

The cylinders normal can be used to find a set of arms perpendicular to the normal and each other. Let the arms be unit vectors. A point on or inside the cylinder is described by a vector equation.

$C1 = C1.pos + t_{1} C1.nml$
$+ r_{1} \cos (θ) C1.arm1$
$+ r_{1} \sin (θ) C1.arm2$

The advantage of this method is that it is very easy to describe and get the equations. However you are going to have to have access to a numerical solver that is really good. This is because the test needs to be as fast as possible. If hundreds of thousands of cylinders need to be tested then it does matter!

Proposed Algorithm

This is an algorithm where it may or may not work. Clearly the goal is to get it to work, but I am not going to prove the algorithm as the aim is to find one that detects collision in constant time.

I will verify the algorithm by moving the cylinders in 3D space and looking for a collision which is not identified by the algorithm. When a collision occurs the cylinders turn red in color. If I find a situation where there is an unidentified collision I can save the state and reload it later for investigation.

The trivial case is when the two cylinders are parallel. The next case is when the two cylinders are infinite. If minimizing the two lines does not result in an end point being forced then the infinite case is also valid for this case too.

Finally the capped end case is tested. This is difficult because we face solving inconsistent non linear equations. I am not sure how they are classified but the final equation can be reduced to a linear equation of two variables in one dimension. This can be solved in constant time. The difficulty lies in that inconsistent equations actually represent many different equations when considering if their coefficients are zero or not. So there is a danger of missing cases.

Parallel Cylinders

Use one of the normals as a line equation, find the other cylinders t values where its endpoint planes intersect the line. If the two line intervals do not intersect there is no intersection.

Pick a common t point in the intersection and find the distance between the two planes. If it is less that or equal to the sum of the cylinders radius's then intersection has occurred, else there is no intersection.

Infinite Cylinders

Minimize the distance between a point on each line through the cylinders normals. Then construct two discs representing a cylinder slice.

Let the varying disk be described by a normalized cylinder where t=0 is the start of the cylinder and t=1 the finish. Cap the t values so if the t value is greater than 1 it is made 1, if it is less than 0 it is made 0.

If these disks intersect then the two cylinders are intersecting.

I do not have proof for this. I did a visual check and it seemed ok.

It is my opinion that this test always works for the infinite cylinder case. If wrong then the algorithm will fail. The reasoning is that the intersection is going to occur where the two lines are closest.

Capped End

The other cases have shown no intersection so one or two of the end points are capped. However from the perspective of collision only one of the ends is capped, and the other cylinder is as an infinite case (it can freely be varied). This is because the test now focuses on finding an intersection with the capped disk.

Let $q = A_{1} + B_{1} t$ be a point on the infinite cylinders normal.
Let $p$ be a point in the center of the cap.
Let $w$ if it exists be a point on the infinite cylinders surface.
Let $r$ be the infinite cylinders radius.
Let $B_{2}$ be the capped cylinders normal.

The equations describing this are given. In words the line to the point of intersection is at right angles to the line itself. The distance of the infinite cylinder to the point on the cylinders surface is fixed and hence gives the third equation.

Now this situation is when the cylinders intersect. So if the cylinders do not intersect this set of equations has no solution.

$B_{1} \cdot (w - q) = 0$
$B_{1} (w - A_{1} - B_{1} t) = 0$
$B_{1} w - B_{1}^{2} t = A_{1} B_{1}$

$B_{2} \cdot (w - p) = 0$
$B_{2} w = B_{2} p$

$(q - w) \cdot (q - w) = r^{2}$

This gives 3 equations with 4 unknowns. Because the last equation is a quadratic, substitute the other two equations in to it. When eliminating a variable test that its coefficient is non-zero. So the elimination will have to by dynamic else there are 7 by 7 cases to consider (49 different equations to solve for). Then solve for t in the quadratic investigating the two solutions if the first fails. This last equation is also be a quadratic in the solving variable. The last equation has two variables in 1D, hopefully the choice of value in the second variable does not matter.

As you can see this is not easy to implement. However if the last equation is easy to implement (which it may be), then it should work.

Algorithm2

Subdivide a bounding box from 4,8,16,32,.. sides. Perhaps choose the cutting planes intersection point randomly so that a fixed pattern can not be found. If after k iterations no collision is detected then the cylinders to not intersect.

This is effectively partitioning the circle over time.

The algorithm is quadratic for each iteration so limit the number of possible collisions in these cases.

This is the easiest algorithm so far to implement.