174 lines
6.2 KiB
C#
174 lines
6.2 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Medallion.Collections;
|
|
|
|
namespace TMI_practicum
|
|
{
|
|
public static class SweepLineEffAlgorithm
|
|
{
|
|
public static IEnumerable<Intersection> Solve(IEnumerable<Circle> circles)
|
|
{
|
|
var intersections = new HashSet<Intersection>();
|
|
var events = new PriorityQueue<Event>();
|
|
var active = new C5.TreeDictionary<SegmentKey, Circle>();
|
|
|
|
|
|
foreach (var circle in circles)
|
|
{
|
|
events.Enqueue(new Event(Event.EventType.Start, circle.X - circle.R, circle, circle.Y));
|
|
events.Enqueue(new Event(Event.EventType.End, circle.X + circle.R, circle, circle.Y));
|
|
}
|
|
|
|
while (events.Count != 0)
|
|
{
|
|
Event e = events.Dequeue();
|
|
int hash = e.GetHashCode();
|
|
switch (e.Type)
|
|
{
|
|
case Event.EventType.Start:
|
|
active.Add(
|
|
new SegmentKey(e.Circle.X, e.Circle.Y + e.Circle.R, SegmentKey.SegmentType.Upper, hash), e.Circle);
|
|
active.Add(
|
|
new SegmentKey(e.Circle.X, e.Circle.Y - e.Circle.R, SegmentKey.SegmentType.Bottom, hash),
|
|
e.Circle);
|
|
|
|
CheckIntersections(active, e, intersections, true, events);
|
|
CheckIntersections(active, e, intersections, false, events);
|
|
break;
|
|
case Event.EventType.End:
|
|
CheckIntersections(active, e, intersections, true, events);
|
|
CheckIntersections(active, e, intersections, false, events);
|
|
active.Remove(new SegmentKey(e.Circle.X, e.Circle.Y + e.Circle.R, SegmentKey.SegmentType.Upper,
|
|
hash));
|
|
active.Remove(new SegmentKey(e.Circle.X, e.Circle.Y - e.Circle.R, SegmentKey.SegmentType.Bottom,
|
|
hash));
|
|
break;
|
|
case Event.EventType.Intersection:
|
|
CheckIntersections(active, e, intersections, true, events);
|
|
CheckIntersections(active, e, intersections, false, events);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
return intersections;
|
|
}
|
|
|
|
private static void CheckIntersections(C5.TreeDictionary<SegmentKey, Circle> active, Event e,
|
|
HashSet<Intersection> intersections, bool upper, PriorityQueue<Event> events)
|
|
{
|
|
|
|
C5.KeyValuePair<SegmentKey, Circle> other;
|
|
|
|
if (upper)
|
|
{
|
|
if (!active.TrySuccessor(new SegmentKey(e.X, e.Y, SegmentKey.SegmentType.Upper,
|
|
e.GetHashCode()), out other))
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (!active.TryPredecessor(
|
|
new SegmentKey(e.X, e.Y, SegmentKey.SegmentType.Bottom, e.GetHashCode()), out other))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
var intersects = e.Circle.FindIntersections(other.Value);
|
|
if (intersects == null) return;
|
|
foreach (var intersection in intersects)
|
|
{
|
|
if (intersections.Contains(intersection)) continue;
|
|
events.Add(new Event(Event.EventType.Intersection, intersection.X, e.Circle, intersection.Y));
|
|
intersections.Add(intersection);
|
|
}
|
|
}
|
|
|
|
private struct Event : IComparable<Event>
|
|
{
|
|
public EventType Type { get; }
|
|
public Circle Circle { get; }
|
|
public double X { get; }
|
|
public double Y { get; }
|
|
|
|
public enum EventType
|
|
{
|
|
Start,
|
|
Intersection,
|
|
End
|
|
}
|
|
|
|
public Event(EventType type, double x, Circle circle, double y)
|
|
{
|
|
Type = type;
|
|
X = x;
|
|
Circle = circle;
|
|
Y = y;
|
|
}
|
|
|
|
public int CompareTo(Event other)
|
|
{
|
|
return X.CompareTo(other.X);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
unchecked // Overflow is fine, just wrap
|
|
{
|
|
int hash = 17;
|
|
// Suitable nullity checks etc, of course :)
|
|
hash = hash * 23 + Type.GetHashCode();
|
|
hash = hash * 23 + X.GetHashCode();
|
|
hash = hash * 23 + Y.GetHashCode();
|
|
return hash;
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SegmentKey : IComparable<SegmentKey>
|
|
{
|
|
private readonly double _x;
|
|
private readonly double? _y;
|
|
private double Y => _y ?? double.MinValue;
|
|
private readonly SegmentType _type;
|
|
private readonly int _identifier;
|
|
|
|
public SegmentKey(double x, double y, SegmentType type, int identifier)
|
|
{
|
|
_y = y;
|
|
_type = type;
|
|
_identifier = identifier;
|
|
_x = x;
|
|
}
|
|
|
|
public int CompareTo(SegmentKey other)
|
|
{
|
|
if (_identifier.Equals(other._identifier)) return _type.CompareTo(other._type);
|
|
if (!_y.Equals(other._y)) return Y.CompareTo(other.Y);
|
|
|
|
return _type.Equals(other._type) ? _x.CompareTo(other._x) : _type.CompareTo(other._type);
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj == null || GetType() != obj.GetType()) return false;
|
|
SegmentKey r = (SegmentKey) obj;
|
|
|
|
return _identifier.Equals(r._identifier) && _type.Equals(r._type);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return _identifier.GetHashCode() ^ _type.GetHashCode();
|
|
}
|
|
|
|
public enum SegmentType
|
|
{
|
|
Bottom,
|
|
Upper
|
|
}
|
|
}
|
|
}
|
|
} |