/// <summary> /// Function returns faces connected to each edge. Result holds indexes to BasicEdges and BasicTriangles, respectively. /// </summary> public Dictionary <int, List <int> > GetEdgeFacesData() { Dictionary <int, List <int> > edgeFaces = new Dictionary <int, List <int> >(); var basicTriangles = BasicTriangles; var basicEdges = BasicEdges; for (int t = 0; t < basicTriangles.Count; t++) { BasicTriangle basicTriangle = basicTriangles[t]; for (int e = 0; e < basicEdges.Count; e++) { BasicEdge basicEdge = basicEdges[e]; if (basicTriangle.ContainsEdge(basicEdge)) { if (!edgeFaces.ContainsKey(e)) { edgeFaces.Add(e, new List <int>()); } edgeFaces[e].Add(t); } } } return(edgeFaces); }
//////////////////////////////////// private void dumpEdge(BasicEdge e) { writeTabs(); cfgFile.Write( "\"" + e.source.label + "\" -> \"" + e.target.label + "\" [ label=<"); // cfgFile.WriteLine("AAA"); if (e.guard.ToString() != "") { cfgFile.Write( "<FONT face=\"Arial Unicode MS\">" + transformCommandForDisplay(e.guard.ToString()) + "</FONT>"); } cfgFile.WriteLine(">" + "]; "); }
public ConditionalBranch(BasicBlock source, ProgramVariable condition, BasicBlock trueTarget, BasicBlock falseTarget) { Debug.Assert(source != null); Debug.Assert(trueTarget != null); Debug.Assert(falseTarget != null); Debug.Assert(condition != null); trueBranch = new BasicEdge(source, trueTarget, new BasicEdge.Guard(new BasicProgramVariableExpression(condition))); falseBranch = new BasicEdge(source, falseTarget, new BasicEdge.Guard(makeNegation(new BasicProgramVariableExpression(condition)))); this.condition = condition; }
public override IEnumerable <object> Solve(TextReader inputStream) { var(n, m) = inputStream.ReadValue <int, int>(); var edges = new BasicEdge[n - 1 + m]; var graph = new BasicGraph(n); var inDegrees = new int[n]; var invertedGraph = new BasicGraph(n); for (int i = 0; i < edges.Length; i++) { var(from, to) = inputStream.ReadValue <int, int>(); from--; to--; var edge = new BasicEdge(from, to); edges[i] = edge; inDegrees[to]++; graph.AddEdge(edge); invertedGraph.AddEdge(new BasicEdge(to, from)); } var sortedNodes = TopologicalSort(graph, inDegrees); var sortedNodesPositions = new int[n]; for (int i = 0; i < sortedNodesPositions.Length; i++) { var node = sortedNodes[i]; sortedNodesPositions[node] = i; } for (int i = 0; i < n; i++) { var parents = invertedGraph[i].ToArray(); var answer = -1; var answerPosition = -1; foreach (var parent in parents) { var position = sortedNodesPositions[parent.To.Index]; if (answerPosition < position) { answerPosition = position; answer = parent.To.Index; } } yield return(answer + 1); } }
public bool ContainsEdge(BasicEdge edge) { bool found = false; foreach (int vertex in v) { if (edge.ContainsVertex(vertex)) { if (found) { return(true); } found = true; } } return(false); }
public override IEnumerable <object> Solve(TextReader inputStream) { var(nodeCount, edgeCount) = inputStream.ReadValue <int, int>(); var edges = new BasicEdge[edgeCount]; for (int i = 0; i < edgeCount; i++) { var(a, b) = inputStream.ReadValue <int, int>(); a--; b--; edges[i] = new BasicEdge(a, b); } var graph = new BasicGraph(nodeCount, edges); List <int> minCycle = null; for (int startIndex = 0; startIndex < nodeCount; startIndex++) { var cycle = Bfs(new BasicNode(startIndex), graph); if (cycle != null && (minCycle == null || minCycle.Count > cycle.Count)) { minCycle = cycle; } } if (minCycle != null) { yield return(minCycle.Count); foreach (var node in minCycle) { yield return(node + 1); } } else { yield return(-1); } }
public UnconditionalBranch(BasicBlock source, BasicBlock target) { Debug.Assert(source != null); Debug.Assert(target != null); successor = new BasicEdge(source, target, new BasicEdge.Guard(true)); }
public void AlgorithmRandomIncremental() { ClearIfNecessary(); if (mDataCloud.Count < 4) { Debugger.Get.Log("Insufficient points to generate a tetrahedron.", DebugOption.CH3); return; } int index = 0; // Pick first point. KeyValuePair <int, Vector3> P1 = new KeyValuePair <int, Vector3>(index, mDataCloud[index]); KeyValuePair <int, Vector3> P2 = new KeyValuePair <int, Vector3>(-1, Vector3.zero); while (P2.Key == -1 && ++index < mDataCloud.Count) { // Two points form a line if they are not equal. Vector3 P = mDataCloud[index]; if (!ExtMathf.Equal(P2.Value, P)) { P2 = new KeyValuePair <int, Vector3>(index, P); } } if (P2.Key == -1) { Debugger.Get.Log("Couldn't find two not equal points.", DebugOption.CH3); return; } // Points on line and on the same plane, still should be considered later on. Happens. List <int> skippedPoints = new List <int>(); Edge line = new Edge(P1.Value, P2.Value); KeyValuePair <int, Vector3> P3 = new KeyValuePair <int, Vector3>(-1, Vector3.zero); while (P3.Key == -1 && ++index < mDataCloud.Count) { // Three points form a triangle if they are not on the same line. Vector3 P = mDataCloud[index]; if (!line.CalculateIfIsOnLine(P)) { P3 = new KeyValuePair <int, Vector3>(index, P); } else { skippedPoints.Add(index); } } if (P3.Key == -1) { Debugger.Get.Log("Couldn't find three not linear points.", DebugOption.CH3); return; } Triangle planeTriangle = new Triangle(P1.Value, P2.Value, P3.Value); KeyValuePair <int, Vector3> P4 = new KeyValuePair <int, Vector3>(-1, Vector3.zero); while (P4.Key == -1 && ++index < mDataCloud.Count) { // Four points form a tetrahedron if they are not on the same plane. Vector3 P = mDataCloud[index]; if (planeTriangle.CalculateRelativePosition(P) != 0) { P4 = new KeyValuePair <int, Vector3>(index, P); } else { skippedPoints.Add(index); } } if (P4.Key == -1) { Debugger.Get.Log("Couldn't find four not planar points.", DebugOption.CH3); return; } // Calculate reference centroid of ConvexHull. Vector3 centroid = ExtMathf.Centroid(P1.Value, P2.Value, P3.Value, P4.Value); List <BasicTriangle> tetrahedronTriangles = new List <BasicTriangle>(); tetrahedronTriangles.Add(new BasicTriangle(P3.Key, P2.Key, P1.Key)); tetrahedronTriangles.Add(new BasicTriangle(P1.Key, P2.Key, P4.Key)); tetrahedronTriangles.Add(new BasicTriangle(P2.Key, P3.Key, P4.Key)); tetrahedronTriangles.Add(new BasicTriangle(P3.Key, P1.Key, P4.Key)); foreach (BasicTriangle basicTriangle in tetrahedronTriangles) { Triangle triangle = new Triangle( mDataCloud[basicTriangle.v[0]], mDataCloud[basicTriangle.v[1]], mDataCloud[basicTriangle.v[2]] ); if (triangle.CalculateRelativePosition(centroid) != -1) { // Centroid of ConvexHull should always be inside. basicTriangle.Reverse(); } mBasicTriangles.Add(basicTriangle); } Dictionary <int, HashSet <BasicTriangle> > pointFacets = new Dictionary <int, HashSet <BasicTriangle> >(); Dictionary <BasicTriangle, HashSet <int> > facetPoints = new Dictionary <BasicTriangle, HashSet <int> >(); foreach (BasicTriangle basicTriangle in mBasicTriangles) { Triangle triangle = new Triangle( mDataCloud[basicTriangle.v[0]], mDataCloud[basicTriangle.v[1]], mDataCloud[basicTriangle.v[2]] ); for (int p = index; p < mDataCloud.Count; p++) { if (triangle.CalculateRelativePosition(mDataCloud[p]) == 1) { if (!pointFacets.ContainsKey(p)) { pointFacets.Add(p, new HashSet <BasicTriangle>()); } pointFacets[p].Add(basicTriangle); if (!facetPoints.ContainsKey(basicTriangle)) { facetPoints.Add(basicTriangle, new HashSet <int>()); } facetPoints[basicTriangle].Add(p); } } foreach (int p in skippedPoints) { if (triangle.CalculateRelativePosition(mDataCloud[p]) == 1) { if (!pointFacets.ContainsKey(p)) { pointFacets.Add(p, new HashSet <BasicTriangle>()); } pointFacets[p].Add(basicTriangle); facetPoints[basicTriangle].Add(p); } } } while (pointFacets.Count > 0) { var firstPointFacet = pointFacets.First(); if (firstPointFacet.Value.Count > 0) { Dictionary <BasicEdge, BasicEdge> horizon = new Dictionary <BasicEdge, BasicEdge>(); foreach (BasicTriangle basicTriangle in firstPointFacet.Value) { for (int a = 2, b = 0; b < 3; a = b++) { BasicEdge edge = new BasicEdge(basicTriangle.v[a], basicTriangle.v[b]); BasicEdge edgeUnordered = edge.Unordered(); if (horizon.ContainsKey(edgeUnordered)) { horizon.Remove(edgeUnordered); } else { horizon.Add(edgeUnordered, edge); } } } int pointKey = firstPointFacet.Key; foreach (BasicTriangle facet in firstPointFacet.Value) { foreach (int facetPointKey in facetPoints[facet]) { if (facetPointKey != pointKey) { pointFacets[facetPointKey].Remove(facet); } } facetPoints.Remove(facet); mBasicTriangles.Remove(facet); } pointFacets.Remove(pointKey); foreach (KeyValuePair <BasicEdge, BasicEdge> edges in horizon) { BasicTriangle newBasicTriangle = new BasicTriangle(edges.Value.v[0], edges.Value.v[1], pointKey); mBasicTriangles.Add(newBasicTriangle); if (pointFacets.Count > 0) { Triangle newTriangle = new Triangle( mDataCloud[newBasicTriangle.v[0]], mDataCloud[newBasicTriangle.v[1]], mDataCloud[newBasicTriangle.v[2]] ); foreach (var pointFacetsKey in pointFacets.Keys) { if (newTriangle.CalculateRelativePosition(mDataCloud[pointFacetsKey]) == 1) { pointFacets[pointFacetsKey].Add(newBasicTriangle); if (!facetPoints.ContainsKey(newBasicTriangle)) { facetPoints.Add(newBasicTriangle, new HashSet <int>()); } facetPoints[newBasicTriangle].Add(pointFacetsKey); } } } } } else { pointFacets.Remove(firstPointFacet.Key); } } }