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); }