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