Indeed a very nice answer!

If Thomas wants to to prevent close-calls, then one has to just do it 'geometrically', this is however much more tricky and time-consuming I'm afraid...

Finding the overlaps can be done in $n^2$ time as Hans said, but it can be done faster if one bins (the centers of) the sticks in bins with a width of the length of the bins. Then only check 'overlaps' for elements in 1 bin, and it's neighbours. This should reduce the $n^2$ a lot if the density is low. If the total 'area' is $A$ then the average density is $n/A$. So in a box of size $L$ you will find roughly $n\times L^2/A$ straws. So you want to check the straws in a box + neighbours it will be at most $ n^2 \times \frac{9L^2}{A}$. So if you're area is big compare to $L^2$, binning and checking neighbours might be a lot faster (binning just takes $n$ time).

Didn't think about the NearestFunction[..][x,{inf,r}] ! that is indeed also fast. Fast and easy implementation. $m\times n\times \log(n)$ scaling right? where $m$ is the average number of candidates in the vicinity?

I will give you just a crude idea using WatershedComponents. That function can find the "ridge" between so called "catchment basins". You have to read up on that to understand. Taht "ridge" is your percolation path. It can also be for example a path in a maze. Alternatively, for general education for percolation coding, take a look at Finding a percolation path, Wolfram Demos, and NKS Book.

So let's go with WatershedComponents now. Your code a bit adjusted for around a percolation threshold:

L = 0.1;
n = 900;
SeedRandom[1]
centers = RandomReal[{0, 1}, {n, 2}];
? = RandomVariate[NormalDistribution[?/2, (1/2.3548)*?/4], n];
stickend1 = centers + Transpose[L {Cos[?], Sin[?]}/2];
stickend2 = centers - Transpose[L {Cos[?], Sin[?]}/2];
lines = Map[Line, Transpose[{stickend1, stickend2}]];
i = Binarize[ColorNegate[Graphics[{Thickness[.0], lines}, PlotRangePadding -> -.02]]]

Now you can find all the ridges, - those are 0-value components spanning the outer boundaries of the catchment basins:

Colorize[MorphologicalComponents[
  WatershedComponents[i, CornerNeighbors -> True] /. {0 -> 1, x_Integer /; x > 0 -> 0}]]

For percolating cluster you select the largest one:

path = SelectComponents[MorphologicalComponents[
    WatershedComponents[i, CornerNeighbors -> True] /. {0 -> 1, x_Integer /; x > 0 -> 0}], 
   "Count", -1] // Image

And you can highlight it on the original image too:

HighlightImage[i, path, Method -> {"Boundary", 2}]

Hi Henrik,

thank you very much!At first I have thought of an approach following graph theory, but this image analysis is sufficient. I thought about using Gwyddion, but I#d prefer keeping all in Mathematica.

Regards

A plausible next step is to form a graph wherein sticks are vertices and edges are based on incidence (that is, overlap) relations. Designate sticks at the top as initial vertical vertices, ones at the bottom as terminal, do similarly for those at left and right. Then graph/network metods can be used to determine existence or number of paths connecting initials to terminals.

Obviously this would take some coding, I just wanted to outline an approach one might pursue following up on this nice use of morphological component separation.

Sounds complicated..... My crude proposal would be: you have a list of sticks (straight lines from A to B). Pick the first one and see, whether it is crossed by another one, then pick this one and do the same and so on, and look whether you reach the opposite end of your domain.

regards Hans

Making percolation paths visible