Maybe I'm missing a subtlety, but wouldn't it be more elegant just to check if the y-intercepts of the two lines are the same? I appreciate that does the same thing as this, but seems like two lines of code.

Sorry, I fear, I do not fully understand your point. Could you give a quick example, please?

mA = (y2 - y1) / (x2 - x1)
mB = (y4 - y3) / (x4 - y4)
if mA == mB
  intA = y2 - mA * x2
  intB = y4 - mB * x4
  if intA == intB
    return true
  return false

But maybe I'm misunderstanding. Do the two lines need to intersect within the line segments? If so, maybe the longer code is necessary, or at least another set of checks if intA==intB

The intersect point do needs to be within both segments (see https://math.stackexchange.com/a/175944 for some math details).
In your example you calculate slopes of the segments similarly to den
but this code will fail for vertical lines (zero division). I fear the equality of
intA and intB is not a sufficient condition of segments' intersect: it looks
this can be True if only (x2, y2) = (x4, y4). Probably, we don't need to check
all 4 points (3 might be enough) for being inside the segment but I need to verify it.

1. Yes, if the slope is infinite, you need to special case
2. If the slope is finite, and the y intercepts the same, then all you need to do is check if x1 < x3 < x2 or x1 < x4 < x2. Much easier.

If the slope is finite we have to:

1. check if intercepts are the same
2. check if one of segments is a part of the other.
   The second part is not quite easy as it might seem, because:
   -- We cannot be sure that x1 < x2 (the same applies for the other pair and y's)
   -- There are many edge cases (x1 = x4, x1 = x2, x3 = x4, x3 = x2, same for y's)

In order to handle all those I've came up with segment_contains which simply checks
if points belongs to a segment (including infinite slopes). The only overhead in segment_contains is the check for intercept, which can be done in the body of
segments_intersect but in that case segment_contains will have a limited use.

I don't agree that its not easy to test "if one segment is part of the other". You only need to check x values because the y values are one-to-one dependent on the x values at this point; and checking the overlap of two intervals is pretty easy (i.e. https://stackoverflow.com/questions/3269434/whats-the-most-efficient-way-to-test-two-integer-ranges-for-overlap)

Still, it needs two separate cases for infinite and non-infinite slopes. Anyway, I will consider writing some simpler code for the equal slopes case.

Well, do the interval check on y instead of x and then most of the code works in both cases... Of course you still need to check for both cases, but the infinite slope case is easy to get if they are on the same line by checking two values of x,

I modified the code, so it makes less checks (not sure if it is more readable though). We still need more checks than you expected because there are many relative positions and orientations of both segments to take into account.

This looks better to me, though I didn't check your math. Note that you could just have the one return statement using y only if you wanted it all to be more elegant. Thanks for sticking with this!

I don't think we can use y's only because of the same reasoning why we cannot use only x's.

If intercept == 0, it doesn't matter if you check y or x, everything is on the same line...

In the intercept == 0, we excluded x = const lines, but if we replace x's with y's in the return statement the code will fail for y = const lines.

Ah, OK, fair enough... Thanks!

Going through 180 angles seems a bit much. Have you checked, that the test still runs fast (<< 1s)? Otherwise it should be sufficient to go through some selected angles like

angles = np.array([0, 30, 45, 90, ...])
angles = np.concatenate([angles, angles+1, angles-1])

@timhoffm, it does take about 1s to complete. I will use the approach you've suggested.

So, I've reduced the total range of angles to 30 so it runs faster.