protected override void UpdatePhysics(TimeSpan duration)
{
Parallel.ForEach(quadTree.AllQuadrants(), quad =>
//foreach(Quadrant quad in quadTree.AllQuadrants())
{
// compare against all other nodes in same quadrant
for (int x = 0; x < quad.Nodes.Count; x++)
{
NodeBase nodeA = quad.Nodes[x];
for (int y = x + 1; y < quad.Nodes.Count; y++)
{
NodeBase nodeB = quad.Nodes[y];
AddRepulsionForce(nodeA, nodeB);
}
}
// compare against all nodes in surrounding quadrants
foreach (NodeBase nodeA in quad.Nodes)
{
foreach (NodeBase nodeB in quad.AdjancentNodes())
{
AddRepulsionForce(nodeA, nodeB);
}
// calc edge forces from this node
for (int j = 0; j < nodeA.FromEdges.Count; j++)
{
EdgeBase edge = nodeA.FromEdges[j];
AddAttractionForce(edge);
}
}
});
}
private void HandleSplitVertex(TVertex vertex)
{
#if DEBUG
int hs = helpers.Count;
#endif
Debug.Assert(GetVertexType(vertex) == VertexType.Split);
// There are no sweep line status modification to be made from above-incident edges
// Add a diagonal from vertex to the helper of the edge directly to the left
EdgeBase rightmostEdge = RightmostEdge(vertex);
KeyValuePair <EdgeBase, TVertex>?directlyLeft = DirectlyLeftOf(rightmostEdge);
if (directlyLeft.HasValue)
{
TVertex helper = directlyLeft.Value.Value;
DiagonalInserterDelegate(mesh, vertex, helper);
helpers[directlyLeft.Value.Key] = vertex;
}
// Add all of the below-indicent edges into the sweep line status (helpers)
// with this vertex as their helper
IEnumerable <EdgeBase> belowEdges = meshUtilities.BelowEdges(vertex);
foreach (EdgeBase edge in belowEdges)
{
helpers[edge] = vertex;
}
#if DEBUG
Debug.Assert(helpers.Count == hs + belowEdges.Count());
#endif
}
private void AddAttractionForce(EdgeBase edge)
{
NodeBase nodeFrom = edge.From;
NodeBase nodeTo = edge.To;
Vector v = nodeFrom.Position - nodeTo.Position;
double dist = v.Length - nodeFrom.Radius - nodeTo.Radius;
dist = Math.Max(dist, 1);
double strength = (Math.Pow(edgeSpring * dist, 1.8)) * nodeFrom.Mass * nodeTo.Mass;
// clip max strength
//strength = Math.Min(strength, 200);
Vector normal = v;
normal.Normalize();
if (strength > 0.1)
{
Vector v2 = strength * normal;
nodeFrom.TotalForce -= v2;
nodeTo.TotalForce += v2;
}
}
public virtual EdgeBase <TVertex> AddEdge(TVertex v0, TVertex v1, double weight = 0)
{
var e = new EdgeBase <TVertex>(v0, v1, weight);
AddEdge(e);
return(e);
}
public void BracedQuadilateral()
{
VertexBase vA = new VertexBase();
VertexBase vB = new VertexBase();
VertexBase vC = new VertexBase();
VertexBase vD = new VertexBase();
mesh.Add(vA);
mesh.Add(vB);
mesh.Add(vC);
mesh.Add(vD);
EdgeBase eA = mesh.AddEdge(vA, vB);
EdgeBase eB = mesh.AddEdge(vB, vC);
EdgeBase eC = mesh.AddEdge(vC, vD);
EdgeBase eD = mesh.AddEdge(vD, vA);
EdgeBase brace = mesh.AddEdge(vA, vC);
Assert.AreNotSame(eA, eB);
Assert.AreNotSame(eB, eC);
Assert.AreNotSame(eC, eD);
Assert.AreNotSame(eD, eA);
Assert.AreNotEqual(eA, brace);
Assert.AreEqual(4, mesh.VertexCount);
Assert.AreEqual(5, mesh.EdgeCount);
Assert.AreEqual(0, mesh.FaceCount);
Assert.AreEqual(3, vA.Degree);
Assert.AreEqual(2, vB.Degree);
Assert.AreEqual(3, vC.Degree);
Assert.AreEqual(2, vD.Degree);
}
public EdgeBase <TVertex> GetEdgeOrCreate(TVertex source, TVertex target, double weight = 0)
{
var edge = GetEdge(source, target);
if (edge == null)
{
AddEdge(edge = new EdgeBase <TVertex>(source, target, weight));
}
return(edge);
}
/// <summary>
/// Given an edge, determine the edge directly to the left of it on the sweep line
/// </summary>
/// <param name="edge">An edge - not necessarily in the sweepline)</param>
/// <returns>If it exists, the edge directly to the left on the sweepline, or null if there is none</returns>
private KeyValuePair <EdgeBase, TVertex>?DirectlyLeftOf(EdgeBase edge)
{
KeyValuePair <EdgeBase, TVertex> result;
bool found = helpers.TryGetLargestBelow(edge, out result);
if (found)
{
return(result);
}
return(null);
}
/// <summary>
/// Given an edge return the upper vertex according to the comparator
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
public TVertex UpperVertex(EdgeBase edge)
{
Point2D source = ((IPositionable2D)edge.Source).Position;
Point2D target = ((IPositionable2D)edge.Target).Position;
int cmp = yxComparer.Compare(source, target);
if (cmp > 0)
{
return((TVertex)edge.Source);
}
return((TVertex)edge.Target);
}
// TODO: This could be an iterator
private List <ChainVertex> TraceRightAndDown(TVertex top)
{
TVertex vertex = top;
List <ChainVertex> result = new List <ChainVertex>();
IEnumerable <EdgeBase> belowEdges;
while ((belowEdges = BelowEdges(vertex)).Count() > 0)
{
EdgeBase edge = sweeplineUtilities.RightMost(belowEdges);
TVertex lower = meshUtilities.LowerVertex(edge);
result.Add(new ChainVertex(lower, Chain.Right));
vertex = lower;
}
return(result);
}
// TODO: This could be an iterator
private List <ChainVertex> TraceLeftAndUp(TVertex bottom)
{
TVertex vertex = bottom;
List <ChainVertex> result = new List <ChainVertex>();
IEnumerable <EdgeBase> aboveEdges;
while ((aboveEdges = AboveEdges(vertex)).Count() > 0)
{
EdgeBase edge = sweeplineUtilities.LeftMost(aboveEdges);
TVertex upper = meshUtilities.UpperVertex(edge);
result.Add(new ChainVertex(upper, Chain.Left));
vertex = upper;
}
return(result);
}
public void DuplicateEdge()
{
VertexBase vA = new VertexBase();
VertexBase vB = new VertexBase();
mesh.Add(vA);
mesh.Add(vB);
EdgeBase edge1 = new EdgeBase();
EdgeBase actualEdge1 = mesh.AddEdge(vA, vB, edge1);
EdgeBase edge2 = new EdgeBase();
EdgeBase actualEdge2 = mesh.AddEdge(vA, vB, edge2);
Assert.AreSame(edge1, actualEdge1);
Assert.AreSame(actualEdge1, actualEdge2);
Assert.AreNotSame(edge2, actualEdge2);
}
/// <summary>
/// Handle collinear vertices of degree two, where both neighbouring
/// vertices have the same y-coordinate.
/// </summary>
/// <param name="vertex">A vertex</param>
private void HandleCollinearVertex(TVertex vertex)
{
var aboveEdges = meshUtilities.AboveEdges(vertex);
Debug.Assert(aboveEdges.Count() == 1);
EdgeBase aboveEdge = aboveEdges.First();
helpers.Remove(aboveEdge);
var belowEdges = meshUtilities.BelowEdges(vertex);
Debug.Assert(belowEdges.Count() == 1);
EdgeBase belowEdge = belowEdges.First();
helpers[belowEdge] = vertex;
}
public void SingleEdge()
{
VertexBase vA = new VertexBase();
VertexBase vB = new VertexBase();
mesh.Add(vA);
mesh.Add(vB);
EdgeBase edge = new EdgeBase();
EdgeBase actualEdge = mesh.AddEdge(vA, vB, edge);
Assert.AreEqual(2, mesh.VertexCount);
Assert.AreEqual(1, mesh.EdgeCount);
Assert.IsFalse(vA.IsIsolated);
Assert.IsFalse(vB.IsIsolated);
Assert.AreSame(edge, actualEdge);
Assert.AreSame(vA, edge.Source);
Assert.AreSame(vB, edge.Target);
}
public static Graph<VertexBase> ParseFileToGraph(string filePath, bool isDirected = false)
{
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
return null;
var vertexDict = new Dictionary<string, VertexBase>();
var result = new Graph<VertexBase>(isDirected);
using (var file = new StreamReader(filePath))
{
string line;
while ((line = file.ReadLine()) != null)
{
if (String.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
continue;
line = line.Trim();
var vertexMatch = ParseVertexLineRegex.Match(line);
if (vertexMatch.Success)
{
var newVertex = new VertexBase(
vertexMatch.Groups["name"].Value,
vertexMatch.Groups["data"].Success ? vertexMatch.Groups["data"].Value : null);
vertexDict.Add(newVertex.Name, newVertex);
result.AddVertex(newVertex);
continue;
}
var edgeMatch = ParseEdgeLineRegex.Match(line);
if (edgeMatch.Success)
{
var newEdge = new EdgeBase<VertexBase>(
vertexDict[edgeMatch.Groups["from"].Value],
vertexDict[edgeMatch.Groups["to"].Value]);
if (edgeMatch.Groups["weight"].Success && double.TryParse(edgeMatch.Groups["weight"].Value, out double weight))
newEdge.Weight = weight;
result.AddEdge(newEdge);
}
}
}
return result;
}
public void Tetrahedron()
{
VertexBase vA = new VertexBase();
VertexBase vB = new VertexBase();
VertexBase vC = new VertexBase();
VertexBase vD = new VertexBase();
mesh.Add(vA);
mesh.Add(vB);
mesh.Add(vC);
mesh.Add(vD);
EdgeBase e1 = mesh.AddEdge(vA, vB);
EdgeBase e2 = mesh.AddEdge(vB, vC);
EdgeBase e3 = mesh.AddEdge(vC, vA);
EdgeBase e4 = mesh.AddEdge(vA, vD);
EdgeBase e5 = mesh.AddEdge(vB, vD);
EdgeBase e6 = mesh.AddEdge(vC, vD);
FaceBase fa = mesh.AddFace(e1, e2, e3);
FaceBase fb = mesh.AddFace(e1, e5, e4);
FaceBase fc = mesh.AddFace(e2, e6, e5);
FaceBase fd = mesh.AddFace(e3, e4, e6);
Assert.AreNotEqual(e1, e2);
Assert.AreNotEqual(e2, e3);
Assert.AreNotEqual(e3, e4);
Assert.AreNotEqual(e4, e5);
Assert.AreNotEqual(e5, e6);
Assert.AreEqual(3, vA.Degree);
Assert.AreEqual(3, vB.Degree);
Assert.AreEqual(3, vC.Degree);
Assert.AreEqual(3, vD.Degree);
Assert.AreEqual(4, mesh.VertexCount);
Assert.AreEqual(6, mesh.EdgeCount);
Assert.AreEqual(3, fa.EdgeCount);
Assert.AreEqual(3, fb.EdgeCount);
Assert.AreEqual(3, fc.EdgeCount);
Assert.AreEqual(3, fd.EdgeCount);
}
public void Triangle()
{
VertexBase vA = new VertexBase();
VertexBase vB = new VertexBase();
VertexBase vC = new VertexBase();
mesh.Add(vA);
mesh.Add(vB);
mesh.Add(vC);
EdgeBase eA = mesh.AddEdge(vB, vC);
EdgeBase eB = mesh.AddEdge(vC, vA);
EdgeBase eC = mesh.AddEdge(vA, vB);
Assert.AreNotSame(eA, eB);
Assert.AreNotSame(eB, eC);
Assert.AreNotSame(eC, eA);
Assert.AreEqual(2, vA.Degree);
Assert.AreEqual(2, vB.Degree);
Assert.AreEqual(2, vC.Degree);
}
public void AddEdge(EdgeBase <TVertex> edge)
{
if (_nameVertexDictionary.TryGetValue(edge.Source.Name, out TVertex origSourceVertex) && origSourceVertex != edge.Source)
{
throw new InvalidDataException($"Vertex '{edge.Source.Name}' already exists but is diffrent than the given one.");
}
if (_nameVertexDictionary.TryGetValue(edge.Target.Name, out TVertex origTargetVertex) && origTargetVertex != edge.Target)
{
throw new InvalidDataException($"Vertex '{edge.Source.Name}' already exists but is diffrent than the given one.");
}
_nameVertexDictionary[edge.Source.Name] = edge.Source;
_nameVertexDictionary[edge.Target.Name] = edge.Target;
_vertexEdgeDictionary.Add(edge.Source, edge);
if (edge.Source != edge.Target)
{
_vertexEdgeDictionary.Add(edge.Target, edge);
}
_edgeList.Add(edge);
}
public void CollinearTest()
{
Vertex a = new Vertex(0, 0);
Vertex b = new Vertex(5, 0);
Vertex c = new Vertex(10, 0);
Vertex d = new Vertex(10, 5);
Vertex e = new Vertex(10, 10);
Vertex f = new Vertex(5, 10);
Vertex g = new Vertex(0, 10);
Vertex h = new Vertex(0, 5);
var vertices = new[] { a, b, c, d, e, f, g, h, };
var mesh = new Mesh <Vertex, EdgeBase, FaceBase>(vertices);
EdgeBase ab = mesh.AddEdge(a, b);
EdgeBase bc = mesh.AddEdge(b, c);
EdgeBase cd = mesh.AddEdge(c, d);
EdgeBase de = mesh.AddEdge(d, e);
EdgeBase ef = mesh.AddEdge(e, f);
EdgeBase fg = mesh.AddEdge(f, g);
EdgeBase gh = mesh.AddEdge(g, h);
EdgeBase ha = mesh.AddEdge(h, a);
var myp = new MonotoneYPartitioner <Vertex, EdgeBase, FaceBase>(mesh);
Mesh <Vertex, EdgeBase, FaceBase> result = myp.GetResult();
Assert.AreEqual(8, result.VertexCount);
Assert.AreEqual(8, result.EdgeCount);
// Check for input edges
Assert.AreEqual(ab, mesh.Find(a, b));
Assert.AreEqual(bc, mesh.Find(b, c));
Assert.AreEqual(cd, mesh.Find(c, d));
Assert.AreEqual(de, mesh.Find(d, e));
Assert.AreEqual(ef, mesh.Find(e, f));
Assert.AreEqual(fg, mesh.Find(f, g));
Assert.AreEqual(gh, mesh.Find(g, h));
Assert.AreEqual(ha, mesh.Find(h, a));
}
public VisualEdge(EdgeBase <VertexBase> edge, Dictionary <string, VisualVertex> vertexDict) : base(vertexDict[edge.Source.Name], vertexDict[edge.Target.Name])
{
Edge = edge;
}
public void RemoveEdge(EdgeBase <TVertex> edge)
{
_vertexEdgeDictionary.Remove(edge.Source, edge);
_vertexEdgeDictionary.Remove(edge.Target, edge);
_edgeList.Remove(edge);
}
public void AddEdge(EdgeBase <TVertex> e)
{
edges.Add(e);
}
public void Init()
{
mesh = new Mesh <Vertex, EdgeBase, FaceBase>(false, true);
v1 = new Vertex(3, 10);
v2 = new Vertex(3, 6);
v3 = new Vertex(6, 8);
v4 = new Vertex(3, 3);
v6 = new Vertex(13, 4);
v7 = new Vertex(13, 11);
mesh.Add(v1);
mesh.Add(v2);
edgeTwoToOne = mesh.AddEdge(v2, v1);
edgeTwoToOne2 = mesh.AddEdge(v2, v1);
edgeOneToTwo = mesh.AddEdge(v1, v2);
mesh.Add(v3);
edgeThreeToTwo = mesh.AddEdge(v3, v2);
edgeTwoToThree = mesh.AddEdge(v2, v3);
mesh.Add(v4);
edgeFourToThree = mesh.AddEdge(v4, v3);
mesh.Add(v7);
mesh.Add(v6);
edgeSevenToSix = mesh.AddEdge(v7, v6);
v100 = new Vertex(101, 103);
v101 = new Vertex(103, 103);
v102 = new Vertex(108, 103);
v103 = new Vertex(107, 103);
v104 = new Vertex(109, 103);
v105 = new Vertex(104, 101);
v106 = new Vertex(106, 106);
mesh.Add(v100);
mesh.Add(v101);
e100to101 = mesh.AddEdge(v100, v101);
mesh.Add(v101);
mesh.Add(v102);
e101to102 = mesh.AddEdge(v101, v102);
mesh.Add(v103);
mesh.Add(v104);
e103to104 = mesh.AddEdge(v103, v104);
mesh.Add(v105);
mesh.Add(v106);
e105to106 = mesh.AddEdge(v105, v106);
v200 = new Vertex(210, 180);
v201 = new Vertex(90, 180);
v202 = new Vertex(90, 60);
mesh.Add(v200);
mesh.Add(v201);
mesh.Add(v202);
e200to201 = mesh.AddEdge(v200, v201);
e202to201 = mesh.AddEdge(v202, v201);
v300 = new Vertex(210, 180);
v301 = new Vertex(90, 180);
v302 = new Vertex(90, 60);
v303 = new Vertex(90, 170);
mesh.Add(v300);
mesh.Add(v301);
mesh.Add(v302);
mesh.Add(v303);
e300to301 = mesh.AddEdge(v300, v301);
e302to303 = mesh.AddEdge(v302, v303);
comparer = new LeftToRightEdgeComparer();
}
public void AddEdge(EdgeBase edge)
{
myCanvas.AddEdge(edge);
}
void UserControl_MouseDown(object sender, MouseButtonEventArgs e)
{
e.Handled = true;
//Point p1 = e.GetPosition(this);
//Point p2 = myCanvas.ToWorldCoordinates(p1);
Keyboard.Focus(this);
mouseDownPoint = e.GetPosition(myCanvas);
CaptureMouse();
Quadrant q = myCanvas.QuadTree.GetQuadrant(mouseDownPoint);
NodeBase mouseDownNode = myCanvas.NodeFromPoint(mouseDownPoint);
EdgeBase mouseDownEdge = myCanvas.EdgeFromPoint(mouseDownPoint);
clickedNode = mouseDownNode;
if (e.ChangedButton == MouseButton.Left)
{
if (mouseDownNode != null)
{
if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
{
mouseMode = MouseMode.AddingEdge;
}
else
{
mouseMode = MouseMode.DraggingNode;
OnNodeClicked(clickedNode, e);
//if (e.ClickCount == 1)
//{
//}
//else if (e.ClickCount == 2)
//{
// for (int i = 0; i < 10; i++)
// {
// Point p = new Point(clickedNode.Position.X + 10 + (5 * i), clickedNode.Position.Y);
// NodeBase n = new Node(p, 1, clickedNode.Colour);
// EdgeBase edge = new Edge(clickedNode, n);
// myCanvas.AddNode(n);
// myCanvas.AddEdge(edge);
// }
//}
}
}
else if (mouseDownEdge != null)
{
}
else
{
selectedNodes.Clear();
selectedEdges.Clear();
clickedNode = null;
if (Keyboard.Modifiers.HasFlag(ModifierKeys.Shift))
{
mouseMode = MouseMode.MarqueeSelecting;
}
else
{
mouseMode = MouseMode.Panning;
}
}
}
}
public void BoundingBoxWithPlanarSubdivision3Test()
{
Vertex a = new Vertex(8, 14);
Vertex b = new Vertex(3, 10);
Vertex c = new Vertex(3, 6);
Vertex d = new Vertex(6, 8);
Vertex e = new Vertex(3, 3);
Vertex f = new Vertex(8, 1);
Vertex g = new Vertex(13, 4);
Vertex h = new Vertex(13, 11);
Vertex b1 = new Vertex(2, 10);
Vertex f1 = new Vertex(8, 9);
Vertex bb1 = new Vertex(0, 0);
Vertex bb2 = new Vertex(15, 0);
Vertex bb3 = new Vertex(15, 15);
Vertex bb4 = new Vertex(0, 15);
var vertices = new[] { a, b, c, d, e, f, g, h, b1, f1, bb1, bb2, bb3, bb4 };
var mesh = new Mesh <Vertex, EdgeBase, FaceBase>(vertices);
EdgeBase ab = mesh.AddEdge(a, b);
EdgeBase bc = mesh.AddEdge(b, c);
EdgeBase cd = mesh.AddEdge(c, d);
EdgeBase de = mesh.AddEdge(d, e);
EdgeBase ef = mesh.AddEdge(e, f);
EdgeBase fg = mesh.AddEdge(f, g);
EdgeBase gh = mesh.AddEdge(g, h);
EdgeBase ha = mesh.AddEdge(h, a);
EdgeBase b_b1 = mesh.AddEdge(b, b1);
EdgeBase ff1 = mesh.AddEdge(f, f1);
EdgeBase bb1bb2 = mesh.AddEdge(bb1, bb2);
EdgeBase bb2bb3 = mesh.AddEdge(bb2, bb3);
EdgeBase bb3bb4 = mesh.AddEdge(bb3, bb4);
EdgeBase bb4bb1 = mesh.AddEdge(bb4, bb1);
var myp = new MonotoneYPartitioner <Vertex, EdgeBase, FaceBase>(mesh);
Mesh <Vertex, EdgeBase, FaceBase> result = myp.GetResult();
Assert.AreEqual(14, result.VertexCount);
Assert.AreEqual(20, result.EdgeCount);
// Check for input edges
Assert.AreEqual(ab, mesh.Find(a, b));
Assert.AreEqual(bc, mesh.Find(b, c));
Assert.AreEqual(cd, mesh.Find(c, d));
Assert.AreEqual(de, mesh.Find(d, e));
Assert.AreEqual(ef, mesh.Find(e, f));
Assert.AreEqual(fg, mesh.Find(f, g));
Assert.AreEqual(gh, mesh.Find(g, h));
Assert.AreEqual(ha, mesh.Find(h, a));
Assert.AreEqual(b_b1, mesh.Find(b, b1));
Assert.AreEqual(ff1, mesh.Find(f, f1));
Assert.AreEqual(bb1bb2, mesh.Find(bb1, bb2));
Assert.AreEqual(bb2bb3, mesh.Find(bb2, bb3));
Assert.AreEqual(bb3bb4, mesh.Find(bb3, bb4));
Assert.AreEqual(bb4bb1, mesh.Find(bb4, bb1));
// Check for additional edges
Assert.IsNotNull(mesh.Find(a, bb3));
Assert.IsNotNull(mesh.Find(b1, a));
Assert.IsNotNull(mesh.Find(f1, b));
Assert.IsNotNull(mesh.Find(d, f1));
Assert.IsNotNull(mesh.Find(c, e));
Assert.IsNotNull(mesh.Find(f, bb1));
}
public void AddEdge(EdgeBase edge)
{
edges.Add(edge);
Invalidate();
}
public void ConstructFromFourPoints1()
{
Point2D a = new Point2D(0.0, 0.0);
Point2D b = new Point2D(1.0, 1.0);
Point2D c = new Point2D(3.0, 1.0);
Point2D d = new Point2D(4.0, 0.0);
var mesh = AngularBisectorNetwork.CreateFromPolyline(new Point2D[] { a, b, c, d });
Assert.AreEqual(6, mesh.VertexCount);
Assert.AreEqual(5, mesh.EdgeCount);
var aNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(a));
Assert.AreEqual(a, aNode.Position);
Assert.IsNull(aNode.Direction);
var bNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(b));
Assert.AreEqual(b, bNode.Position);
Assert.IsNull(bNode.Direction);
var cNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(c));
Assert.AreEqual(c, cNode.Position);
Assert.IsNull(cNode.Direction);
var dNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(d));
Assert.AreEqual(d, dNode.Position);
Assert.IsNull(dNode.Direction);
Assert.AreEqual(1, aNode.Degree);
Assert.AreEqual(1, bNode.Degree);
Assert.AreEqual(1, cNode.Degree);
Assert.AreEqual(1, dNode.Degree);
var bEnumerator = bNode.Edges.GetEnumerator();
bEnumerator.MoveNext();
EdgeBase bpEdge = bEnumerator.Current;
var cEnumerator = cNode.Edges.GetEnumerator();
cEnumerator.MoveNext();
EdgeBase cpEdge = cEnumerator.Current;
Assert.AreSame(bpEdge.Target, cpEdge.Target);
var pNode = bpEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.AreEqual(2.0, pNode.Position.X);
Assert.AreEqual(-Math.Sqrt(2.0), pNode.Position.Y, epsilon);
Assert.IsNull(pNode.Direction);
var aEnumerator = aNode.Edges.GetEnumerator();
aEnumerator.MoveNext();
EdgeBase aqEdge = aEnumerator.Current;
var dEnumerator = dNode.Edges.GetEnumerator();
dEnumerator.MoveNext();
EdgeBase dqEdge = dEnumerator.Current;
Assert.AreSame(aqEdge.Target, dqEdge.Target);
var qNode = aqEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.AreEqual(2.0, qNode.Position.X);
Assert.AreEqual(-2.0, qNode.Position.Y, epsilon);
EdgeBase pqEdge = mesh.Find(pNode, qNode);
Assert.IsNotNull(pqEdge);
Assert.IsNotNull(qNode.Direction);
Assert.AreEqual(new Direction2D(0.0, -1.0), qNode.Direction);
}
public void ConstructFromFivePointsReflex()
{
Point2D a = new Point2D(0.0, 0.0);
Point2D b = new Point2D(1.0, 0.0);
Point2D c = new Point2D(2.0, -1.0);
Point2D d = new Point2D(3.0, 0.0);
Point2D e = new Point2D(4.0, 0.0);
var mesh = AngularBisectorNetwork.CreateFromPolyline(new Point2D[] { a, b, c, d, e });
Assert.AreEqual(7, mesh.VertexCount);
Assert.AreEqual(4, mesh.EdgeCount);
var aNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(a));
Assert.AreEqual(a, aNode.Position);
Assert.IsNull(aNode.Direction);
var bNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(b));
Assert.AreEqual(b, bNode.Position);
Assert.IsNull(bNode.Direction);
var cNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(c));
Assert.AreEqual(c, cNode.Position);
Assert.IsNotNull(cNode.Direction);
Assert.AreEqual(new Direction2D(0.0, -1.0), cNode.Direction);
var dNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(d));
Assert.AreEqual(d, dNode.Position);
Assert.IsNull(dNode.Direction);
var eNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(e));
Assert.AreEqual(e, eNode.Position);
Assert.IsNull(eNode.Direction);
Assert.AreEqual(1, aNode.Degree);
Assert.AreEqual(1, bNode.Degree);
Assert.AreEqual(0, cNode.Degree);
Assert.AreEqual(1, dNode.Degree);
Assert.AreEqual(1, eNode.Degree);
var aEnumerator = aNode.Edges.GetEnumerator();
aEnumerator.MoveNext();
EdgeBase apEdge = aEnumerator.Current;
var bEnumerator = bNode.Edges.GetEnumerator();
bEnumerator.MoveNext();
EdgeBase bpEdge = bEnumerator.Current;
Assert.AreSame(apEdge.Target, bpEdge.Target);
var pNode = apEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.AreEqual(0.0, pNode.Position.X);
Assert.AreEqual(-1.0 - Math.Sqrt(2.0), pNode.Position.Y, epsilon);
Assert.IsNotNull(pNode.Direction);
Assert.AreEqual(2, pNode.Degree);
Assert.AreEqual(-1.9634954084936209, pNode.Direction.Value.Bearing, epsilon);
var dEnumerator = dNode.Edges.GetEnumerator();
dEnumerator.MoveNext();
EdgeBase dqEdge = dEnumerator.Current;
var eEnumerator = eNode.Edges.GetEnumerator();
eEnumerator.MoveNext();
EdgeBase eqEdge = eEnumerator.Current;
Assert.AreSame(dqEdge.Target, eqEdge.Target);
var qNode = dqEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.AreEqual(4.0, qNode.Position.X);
Assert.AreEqual(-1.0 - Math.Sqrt(2.0), qNode.Position.Y, epsilon);
Assert.IsNotNull(qNode.Direction);
Assert.AreEqual(2, qNode.Degree);
Assert.AreEqual(-1.1780972450961724, qNode.Direction.Value.Bearing, epsilon);
}
public void ConstructFromThreePoints()
{
Point2D a = new Point2D(0.0, 0.0);
Point2D b = new Point2D(1.0, 0.0);
Point2D c = new Point2D(2.0, -1.0);
var mesh = AngularBisectorNetwork.CreateFromPolyline(new Point2D[] { a, b, c });
Assert.AreEqual(5, mesh.VertexCount);
Assert.AreEqual(4, mesh.EdgeCount);
var aNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(a));
Assert.AreEqual(a, aNode.Position);
var bNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(b));
Assert.AreEqual(b, bNode.Position);
var cNode = mesh.Find(new AngularBisectorNetwork.BisectorVertex(c));
Assert.AreEqual(c, cNode.Position);
Assert.AreEqual(1, aNode.Degree);
Assert.AreEqual(1, bNode.Degree);
Assert.AreEqual(1, cNode.Degree);
var aEnumerator = aNode.Edges.GetEnumerator();
aEnumerator.MoveNext();
EdgeBase apEdge = aEnumerator.Current;
var bEnumerator = bNode.Edges.GetEnumerator();
bEnumerator.MoveNext();
EdgeBase bpEdge = bEnumerator.Current;
Assert.AreSame(apEdge.Target, bpEdge.Target);
var pNode = apEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.AreEqual(3, pNode.Degree);
Assert.AreEqual(0.0, pNode.Position.X, epsilon);
Assert.AreEqual(-Math.Sqrt(2.0) - 1.0, pNode.Position.Y, epsilon);
var cEnumerator = cNode.Edges.GetEnumerator();
cEnumerator.MoveNext();
EdgeBase cqEdge = cEnumerator.Current;
var qNode = cqEdge.Target as AngularBisectorNetwork.BisectorVertex;
Assert.IsNotNull(qNode);
Assert.AreEqual(2, qNode.Degree);
EdgeBase pqEdge = mesh.Find(pNode, qNode);
Assert.IsNotNull(pqEdge);
Assert.IsNotNull(qNode.Direction);
Assert.AreEqual(-1.9634954084936209, qNode.Direction.Value.Bearing, epsilon);
}
