public static VNode ProcessCircleEvent(VCircleEvent e, VNode root, VoronoiGraph vg, out VDataNode[] circleCheckList)
{
VEdgeNode eo;
VDataNode b = e.NodeN;
VDataNode a = LeftDataNode(b);
VDataNode c = RightDataNode(b);
if (a == null || b.Parent == null || c == null || !a.DataPoint.Equals(e.NodeL.DataPoint) || !c.DataPoint.Equals(e.NodeR.DataPoint))
{
circleCheckList = new VDataNode[] { };
return root; // Abbruch da sich der Graph verändert hat
}
VEdgeNode eu = (VEdgeNode)b.Parent;
circleCheckList = new[] { a, c };
//1. Create the new Vertex
Vector2 vNew = new Vector2(e.Center.X, e.Center.Y);
// VNew[0] = Fortune.ParabolicCut(a.DataPoint[0],a.DataPoint[1],c.DataPoint[0],c.DataPoint[1],ys);
// VNew[1] = (ys + a.DataPoint[1])/2 - 1/(2*(ys-a.DataPoint[1]))*(VNew[0]-a.DataPoint[0])*(VNew[0]-a.DataPoint[0]);
vg.Vertices.Add(vNew);
//2. Find out if a or c are in a distand part of the tree (the other is then b's sibling) and assign the new vertex
if (eu.Left == b) // c is sibling
{
eo = EdgeToRightDataNode(a);
// replace eu by eu's Right
eu.Parent.Replace(eu, eu.Right);
}
else // a is sibling
{
eo = EdgeToRightDataNode(b);
// replace eu by eu's Left
eu.Parent.Replace(eu, eu.Left);
}
eu.Edge.AddVertex(vNew);
// ///////////////////// uncertain
// if(eo==eu)
// return root;
// /////////////////////
eo.Edge.AddVertex(vNew);
//2. Replace eo by new Edge
VoronoiEdge ve = new VoronoiEdge();
ve.LeftData = a.DataPoint;
ve.RightData = c.DataPoint;
ve.AddVertex(vNew);
vg.Edges.Add(ve);
VEdgeNode ven = new VEdgeNode(ve, false);
ven.Left = eo.Left;
ven.Right = eo.Right;
if (eo.Parent == null)
return ven;
eo.Parent.Replace(eo, ven);
return root;
}
/// <summary>
/// Will return the new root (unchanged except in start-up)
/// </summary>
public static VNode ProcessDataEvent(VDataEvent e, VNode root, VoronoiGraph vg, double ys, out VDataNode[] circleCheckList)
{
if (root == null)
{
root = new VDataNode(e.DataPoint);
circleCheckList = new[] { (VDataNode)root };
return root;
}
//1. Find the node to be replaced
VNode c = FindDataNode(root, ys, e.DataPoint.X);
//2. Create the subtree (ONE Edge, but two VEdgeNodes)
VoronoiEdge ve = new VoronoiEdge();
ve.LeftData = ((VDataNode)c).DataPoint;
ve.RightData = e.DataPoint;
ve.VVertexA = Fortune.VVUnkown;
ve.VVertexB = Fortune.VVUnkown;
vg.Edges.Add(ve);
VNode subRoot;
if (Math.Abs(ve.LeftData.Y - ve.RightData.Y) < 1e-10)
{
if (ve.LeftData.X < ve.RightData.X)
{
subRoot = new VEdgeNode(ve, false);
subRoot.Left = new VDataNode(ve.LeftData);
subRoot.Right = new VDataNode(ve.RightData);
}
else
{
subRoot = new VEdgeNode(ve, true);
subRoot.Left = new VDataNode(ve.RightData);
subRoot.Right = new VDataNode(ve.LeftData);
}
circleCheckList = new[] { (VDataNode)subRoot.Left, (VDataNode)subRoot.Right };
}
else
{
subRoot = new VEdgeNode(ve, false);
subRoot.Left = new VDataNode(ve.LeftData);
subRoot.Right = new VEdgeNode(ve, true);
subRoot.Right.Left = new VDataNode(ve.RightData);
subRoot.Right.Right = new VDataNode(ve.LeftData);
circleCheckList = new[] { (VDataNode)subRoot.Left, (VDataNode)subRoot.Right.Left, (VDataNode)subRoot.Right.Right };
}
//3. Apply subtree
if (c.Parent == null)
return subRoot;
c.Parent.Replace(c, subRoot);
return root;
}
/// <summary>
/// Applies an optional cleanup method needed by Benjamine Ditter for
/// laser data calculations. This is not used by the MapWindow calculations
/// </summary>
/// <param name="vg">The output voronoi graph created in the Compute Voronoi Graph section</param>
/// <param name="minLeftRightDist">A minimum left to right distance</param>
/// <returns>The Voronoi Graph after it has been filtered.</returns>
public static VoronoiGraph FilterVg(VoronoiGraph vg, double minLeftRightDist)
{
VoronoiGraph vgErg = new VoronoiGraph();
foreach (VoronoiEdge ve in vg.Edges)
{
if (ve.LeftData.Distance(ve.RightData) >= minLeftRightDist)
vgErg.Edges.Add(ve);
}
foreach (VoronoiEdge ve in vgErg.Edges)
{
vgErg.Vertices.Add(ve.VVertexA);
vgErg.Vertices.Add(ve.VVertexB);
}
return vgErg;
}
/// <summary>
/// The original algorithm simply allows edges that have one defined point and
/// another "NAN" point. Simply excluding the not a number coordinates fails
/// to preserve the known direction of the ray. We only need to extend this
/// long enough to encounter the bounding box, not infinity.
/// </summary>
/// <param name="graph">The VoronoiGraph with the edge list</param>
/// <param name="bounds">The polygon bounding the datapoints</param>
private static void HandleBoundaries(VoronoiGraph graph, IEnvelope bounds)
{
List<ILineString> boundSegments = new List<ILineString>();
List<VoronoiEdge> unboundEdges = new List<VoronoiEdge>();
// Identify bound edges for intersection testing
foreach (VoronoiEdge edge in graph.Edges)
{
if(edge.VVertexA.ContainsNan() || edge.VVertexB.ContainsNan())
{
unboundEdges.Add(edge);
continue;
}
boundSegments.Add(new LineString(new List<Coordinate>{edge.VVertexA.ToCoordinate(), edge.VVertexB.ToCoordinate()}));
}
// calculate a length to extend a ray to look for intersections
IEnvelope env = bounds;
double h = env.Height;
double w = env.Width;
double len = Math.Sqrt(w * w + h * h); // len is now long enough to pass entirely through the dataset no matter where it starts
foreach (VoronoiEdge edge in unboundEdges)
{
// the unbound line passes thorugh start
Coordinate start = (edge.VVertexB.ContainsNan())
? edge.VVertexA.ToCoordinate()
: edge.VVertexB.ToCoordinate();
// the unbound line should have a direction normal to the line joining the left and right source points
double dx = edge.LeftData.X - edge.RightData.X;
double dy = edge.LeftData.Y - edge.RightData.Y;
double l = Math.Sqrt(dx*dx + dy*dy);
// the slope of the bisector between left and right
double sx = -dy/l;
double sy = dx/l;
Coordinate center = bounds.Center();
if((start.X > center.X && start.Y > center.Y) || (start.X < center.X && start.Y < center.Y))
{
sx = dy/l;
sy = -dx/l;
}
Coordinate end1 = new Coordinate(start.X + len*sx, start.Y + len * sy);
Coordinate end2 = new Coordinate(start.X - sx * len, start.Y - sy * len);
Coordinate end = (end1.Distance(center) < end2.Distance(center)) ? end2 : end1;
if(bounds.Contains(end))
{
end = new Coordinate(start.X - sx * len, start.Y - sy * len);
}
if (edge.VVertexA.ContainsNan())
{
edge.VVertexA = new Vector2(end.ToArray());
}
else
{
edge.VVertexB = new Vector2(end.ToArray());
}
}
}
/// <summary>
/// Calculates a list of edges and junction vertices by using the specified points.
/// This defaults to not using any tolerance for determining if points are equal,
/// and will not use the cleanup algorithm, which breaks the HandleBoundaries
/// method in the Voronoi class.
/// </summary>
/// <param name="vertices">The original points to use during the calculation</param>
/// <returns>A VoronoiGraph structure containing the output geometries</returns>
public static VoronoiGraph ComputeVoronoiGraph(double[] vertices)
{
//BinaryPriorityQueue pq = new BinaryPriorityQueue();
SortedDictionary<VEvent, VEvent> pq = new SortedDictionary<VEvent, VEvent>();
Dictionary<VDataNode, VCircleEvent> currentCircles = new Dictionary<VDataNode, VCircleEvent>();
VoronoiGraph vg = new VoronoiGraph();
VNode rootNode = null;
for(int i = 0; i < vertices.Length/2; i++)
{
//pq.Push(new VDataEvent(new Vector(vertex)));
VDataEvent e = new VDataEvent(new Vector2(vertices, i*2));
if (pq.ContainsKey(e)) continue;
pq.Add(e, e);
}
while (pq.Count > 0)
{
//VEvent ve = pq.Pop() as VEvent;
VEvent ve = pq.First().Key;
pq.Remove(ve);
VDataNode[] circleCheckList = new VDataNode[] { };
if (ve is VDataEvent)
{
rootNode = VNode.ProcessDataEvent(ve as VDataEvent, rootNode, vg, ve.Y, out circleCheckList);
}
else if (ve is VCircleEvent)
{
currentCircles.Remove(((VCircleEvent)ve).NodeN);
if (!((VCircleEvent)ve).Valid)
continue;
rootNode = VNode.ProcessCircleEvent(ve as VCircleEvent, rootNode, vg, out circleCheckList);
}
else if (ve != null) throw new Exception("Got event of type " + ve.GetType() + "!");
foreach (VDataNode vd in circleCheckList)
{
if (currentCircles.ContainsKey(vd))
{
currentCircles[vd].Valid = false;
currentCircles.Remove(vd);
}
if (ve == null) continue;
VCircleEvent vce = VNode.CircleCheckDataNode(vd, ve.Y);
if (vce == null) continue;
//pq.Push(vce);
pq.Add(vce, vce);
currentCircles[vd] = vce;
}
if (!(ve is VDataEvent)) continue;
Vector2 dp = ((VDataEvent)ve).DataPoint;
foreach (VCircleEvent vce in currentCircles.Values)
{
if (MathTools.Dist(dp.X, dp.Y, vce.Center.X, vce.Center.Y) < vce.Y - vce.Center.Y && Math.Abs(MathTools.Dist(dp.X, dp.Y, vce.Center.X, vce.Center.Y) - (vce.Y - vce.Center.Y)) > 1e-10)
vce.Valid = false;
}
}
// This is where the MapWindow version should exit since it uses the HandleBoundaries
// function instead. The following code is needed for Benjamin Ditter's original process to work.
if (!DoCleanup) return vg;
VNode.CleanUpTree(rootNode);
foreach (VoronoiEdge ve in vg.Edges)
{
if (ve.Done)
continue;
if (ve.VVertexB != VVUnkown) continue;
ve.AddVertex(VVInfinite);
if (Math.Abs(ve.LeftData.Y - ve.RightData.Y) < 1e-10 && ve.LeftData.X < ve.RightData.X)
{
Vector2 t = ve.LeftData;
ve.LeftData = ve.RightData;
ve.RightData = t;
}
}
ArrayList minuteEdges = new ArrayList();
foreach (VoronoiEdge ve in vg.Edges)
{
if (ve.IsPartlyInfinite || !ve.VVertexA.Equals(ve.VVertexB)) continue;
minuteEdges.Add(ve);
// prevent rounding errors from expanding to holes
foreach (VoronoiEdge ve2 in vg.Edges)
{
if (ve2.VVertexA.Equals(ve.VVertexA))
ve2.VVertexA = ve.VVertexA;
if (ve2.VVertexB.Equals(ve.VVertexA))
ve2.VVertexB = ve.VVertexA;
}
}
foreach (VoronoiEdge ve in minuteEdges)
{
vg.Edges.Remove(ve);
}
return vg;
}