After watching Philipp Kindermann's excellent sweep-line videos I think I finally understand how this algorithm works.
This is my humble take on an implementation of the segment line intersection sweep-line algorithm. \ \ The library crate also contains a line intersection function.
Code still in development, not ready for any purpose.
Interactive step-by-step example:
fish
cargo run --example fltk_gui --features console_trace
Most of this crate have been adapted for nalgebra, cgmath, mint and plain vector here.
Intersection function API example: ```rust use intersection2d::{intersect, Intersection}; use geo;
let line1:geo::Line::
let rv = intersect(&line1, &line2); match _rv { Some(Intersection::Intersection(a)) => panic!("expected an overlap"), Some(Intersection::OverLap(a)) => println!("{:?}", a), None => panic!("expected an overlap"), } // you can also get a single intersection point from the Intersection enum. // Albeit geometrically incorrect, it makes things easy if let Some(rv) =rv { println!("{:?}", _rv.single()); } ```
Sweep-line API example: ```rust use geo; use intersect2d::algorithm::AlgorithmData;
let l = vec![
geo::Line::new(
geo::Coordinate { x: 200., y: 200. },
geo::Coordinate { x: 350., y: 300. },
),
geo::Line::new(
geo::Coordinate { x: 400., y: 200. },
geo::Coordinate { x: 250., y: 300. },
),
];
let results = AlgorithmData::
Detection of self-intersecting geo::LineString: ```rust let coordinates = vec![(200., 200.), (300., 300.), (400., 200.), (200., 300.)]; let line_string = geo::LineString::from(coordinates);
// Obviously this example only makes sense for LinesStrings with many points.
// A simple brute force O(n²) intersection test will be faster than this O(nlog(n)+k)
// sweep-line algorithm if n is small enough.
let result = AlgorithmData::
or using the `SelfIntersectingExclusive` trait:
rust
// SelfIntersectingExclusive does not report endpoint intersections
use intersect2d::SelfIntersectingExclusive;
let coordinates = vec![(200., 200.), (300., 300.), (400., 200.), (200., 300.)]; let line_string = geo::LineString::from(coordinates);
if linestring.isself_intersecting()? { println!("Intersection detected"); }
for intersections in linestring.selfintersections()? { println!("Intersection: {:?}", intersections); } ```
You can also check a bunch of geo::Line for self intersections using the SelfIntersectingInclusive trait:
rust
// SelfIntersectingInclusive reports endpoint intersections
use intersect2d::SelfIntersectingInclusive;
let lines = vec![
geo::Line::new(
geo::Coordinate { x: 200., y: 200. },
geo::Coordinate { x: 350., y: 300. },
),
geo::Line::new(
geo::Coordinate { x: 400., y: 200. },
geo::Coordinate { x: 250., y: 300. },
),
];
if lines.is_self_intersecting_inclusive()? {
println!("Intersection detected");
}
for intersections in lines.self_intersections_inclusive()? {
println!("Intersection: {:?}", intersections);
}