I suspect that there's probably a way to optimize the algorithm, but I really can't think of what it would be. However, there are numerous little changes that might help your performance a bit (though probably nothing too dramatic.

- Why are
`$points` and `$neighborEdges` hashrefs mapping integers (as strings) to values? It seems like it would be much more natural to make them simply arrayrefs (or just arrays). Then you wouldn't need `neighboorCNT`. So then instead of
`for (my $n=1;$n<=$neighboorCNT;$n++) {
if ($neighborEdges->{$n}) {
`

you get
`for my $n (@$neighborEdges){
`

and when instead of using `$neighborEdges->{$n}` you'd just use `$n`. That would save a lot of hash accesses.
- Very minor point, but it looks like you don't actually care about the real distance between points. Instead, you care about relative distances. So you can store the square of the distances (by not doing the sqrt) and get the same results.
- Since
`Determinant` is called so many times, I wonder whether you'd get any improvement over rewriting it without the temporary variables.
`sub Determinant {
return ($_[0]*$_[3] - $_[2]*$_[1]);
}
`

- I'd probably try rethinking SegmentIntersection. Here's an unbenchmarked (and untested) version that tries to save on some of the divisions, save calls you don't need, etc. Basically, if
`$d` is zero, we don't even need `$n1` or `$n2`. For the inequalities, instead of dividing by `$d` again and again, we can multiply both sides of the inequality by `$d` (and flip the inequality if $d is less than zero).
`sub SegmentIntersection {
my @points = @{$_[0]};
my @p1 = @{$points[0]}; # p1,p2 = segment 1
my @p2 = @{$points[1]};
my @p3 = @{$points[2]}; # p3,p4 = segment 2
my @p4 = @{$points[3]};
my $d = Determinant(($p2[0]-$p1[0]),($p3[0]-$p4[0]),
($p2[1]-$p1[1]),($p3[1]-$p4[1]));
if (abs($d) < $delta) {
return 0; # parallel
}
my $n1 = Determinant(($p3[0]-$p1[0]),($p3[0]-$p4[0]),
($p3[1]-$p1[1]),($p3[1]-$p4[1]));
my $n2 = Determinant(($p2[0]-$p1[0]),($p3[0]-$p1[0]),
($p2[1]-$p1[1]),($p3[1]-$p1[1]));
if ($d > 0){
return $n1 < $d && $n2 < $d && $n1 > 0 && $n2 > 0;
} else {
return $n1 > $d && $n2 > $d && $n1 < 0 && $n2 < 0;
}
}
`

All small things, but they might help a little.

Comment onRe: Millions of line segment intersection calcs: Looking for speed tipsSelectorDownloadCode