public void IfCase()
{
BasicBlock.clearIndexCounter();
var cfg = GenerateCFG(
@"
{
a = 3;
b = 2;
c = a + b;
if t
{
a = a;
}
else
{
b = b;
}
}
");
var spanningTree = new SpanningTree(cfg);
var actual = spanningTree.dfst;
var expected = new List <IndexEdge>()
{
new IndexEdge(4, 0),
new IndexEdge(0, 2),
new IndexEdge(2, 3),
new IndexEdge(3, 5),
new IndexEdge(0, 1)
};
Assert.AreEqual(expected, actual);
}
public override void RunAlgorithm(IGraph graph)
{
// reset edge styles
foreach (var edge in graph.Edges)
{
graph.SetStyle(edge, graph.EdgeDefaults.Style);
}
// calculate the spanning tree
var result = new SpanningTree {
Costs = { Delegate = GetEdgeWeight }
}.Run(graph);
// highlight the tree nodes and edges
var nodes = new HashSet <INode>();
foreach (var edge in result.Edges)
{
edge.Tag = new Tag {
CurrentColor = Colors.Blue
};
nodes.Add(edge.GetSourceNode());
nodes.Add(edge.GetTargetNode());
}
foreach (var node in nodes)
{
node.Tag = new Tag {
CurrentColor = Colors.Blue
};
}
}
static void Benchmark(int vertices, int maxEdges, int increment, int repetitions, string filename)
{
Stopwatch timer = new Stopwatch();
using (StreamWriter file = new StreamWriter("Results/Data/" + filename + ".csv"))
{
for (int edges = 10000; edges <= maxEdges; edges += increment)
{
long averageTime = 0;
var rand = new Random();
for (int j = 0; j < repetitions; j++)
{
Graph g = GraphGenerator(vertices, edges);
timer.Start();
SpanningTreeInfo sti = SpanningTree.GetSpanning(g);
timer.Stop();
averageTime += timer.ElapsedMilliseconds;
timer.Reset();
}
averageTime /= repetitions;
file.WriteLine("{0},{1}", edges, averageTime);
Console.WriteLine(edges + " " + averageTime);
}
}
}
public Edge(SpanningTree <T> .Node source, SpanningTree <T> .Node target, int order, T value)
{
this.source = source;
this.target = target;
this.order = order;
this.@value = value;
}
private void ProcessClusters()
{
if (_touchTracker.SpanningTreeCount > 0)
{
UpdateTouchOrder();
for (int i = 0; i < _touchOrder.Count; i++)
{
SpanningTree tree = _touchTracker.GetSpanningTree(_touchOrder[i].TreeIndex);
tree.GetTouchCluster(_cluster);
try
{
var touch = _cluster.Touches[_cluster.ActiveTouchId];
bool processed = ProcessTouch(touch, _cluster);
if (RecordDebugInfo)
{
_debugBuffer.AppendFormat("{0}[{1}]{2}", _cluster.ClusterId, _cluster.ActiveTouchId,
processed ? "* " : "- ");
}
}
catch (Exception e)
{
Debug.LogErrorFormat(this, "Exception processing cluster. {0} touches, activeTouchId = {1}\n{2}",
_cluster.Touches.Count, _cluster.ActiveTouchId, e.ToString());
}
}
_usedTargets.Clear();
}
}
public void TestSplit()
{
var mol = smilesParser.ParseSmiles("C1CC1C2CCC2");
SpanningTree st = new SpanningTree(mol);
IRingSet rings = st.GetAllRings();
IBond splitBond = null;
for (int i = 0; i < mol.Bonds.Count; i++)
{
if (rings.GetRings(mol.Bonds[i]).Count() == 0)
{
splitBond = mol.Bonds[i];
break;
}
}
var frags = FragmentUtils.SplitMolecule(mol, splitBond);
SmilesGenerator sg = new SmilesGenerator();
var uniqueFrags = new HashSet <string>();
foreach (var frag in frags)
{
uniqueFrags.Add(sg.Create(frag));
}
Assert.AreEqual(2, uniqueFrags.Count);
// You can put the fragments back together with a ring closure and dot
// [CH]12CC1.[CH]12CCC1
Assert.IsTrue(uniqueFrags.IsSupersetOf(new[] { "[CH]1CC1", "[CH]1CCC1" }));
}
public MapGraph(List<Node> nodes, List<Edge> edges, DelaunayTriangles dt, SpanningTree spt, List<RoomArea> roomareas)
{
NodeList = nodes;
EdgeList = edges;
DT = dt;
SPT = spt;
RoomAreas = roomareas;
}
public void CanBuildSpanningTreeUsingKruskalAlgorithm()
{
var kruskal = SpanningTree.Kruskal(inputGraph);
Assert.AreEqual(8, kruskal.Vertexes.Count);
Assert.AreEqual(7, kruskal.Edges.Count);
Assert.AreEqual(71, kruskal.Edges.Sum(_ => _.Weight));
}
public void CanBuildSpanningTreeUsingBoruvkaAlgorithm()
{
var boruvka = SpanningTree.Boruvka(inputGraph);
Assert.AreEqual(8, boruvka.Vertexes.Count);
Assert.AreEqual(7, boruvka.Edges.Count);
Assert.AreEqual(71, boruvka.Edges.Sum(_ => _.Weight));
}
private void DisplayTreeInRenderer(LineRenderer lineRenderer, SpanningTree tree)
{
_lines.Clear();
ComputeDisplayEdges(tree.Root, tree);
lineRenderer.positionCount = _lines.Count;
for (int i = 0; i < _lines.Count; i++)
{
lineRenderer.SetPosition(i, _lines[i]);
}
lineRenderer.enabled = true;
}
/// <summary>
/// Identifies a touch cluster which contains a given touch ID
/// </summary>
/// <param name="touchId"></param>
/// <param name="cluster"></param>
/// <returns></returns>
public bool GetTouchClusterForTouchId(int touchId, TouchCluster cluster)
{
for (int i = 0; i < _touchTracker.SpanningTreeCount; i++)
{
SpanningTree tree = _touchTracker.GetSpanningTree(i);
if (tree.ContainsTouchId(touchId))
{
return(tree.GetTouchCluster(cluster));
}
}
cluster.Clear();
return(false);
}
public void Minimum()
{
IGraph <int, WeightedEdge <int> > G = new DirectedGraph <int, WeightedEdge <int> >();
{
G.Vertexes.Add(1);
G.Vertexes.Add(2);
G.Vertexes.Add(3);
G.Edges.Add(new WeightedEdge <int>(1, 2, 1));
G.Edges.Add(new WeightedEdge <int>(1, 3, 1));
G.Edges.Add(new WeightedEdge <int>(2, 3, 2));
}
Assert.AreEqual(2, SpanningTree.MinimumByKruskal(G, WeightedEdge <int> .WeightFunc, out var edges));
Assert.AreEqual(2, edges.Count);
}
public void CalculateMin()
{
this.Reset();
IntrusiveMinHeap <SpanningTree <T> .Edge> intrusiveMinHeap = new IntrusiveMinHeap <SpanningTree <T> .Edge>();
foreach (SpanningTree <T> .Node node in this.nodes)
{
if (node.connected)
{
continue;
}
foreach (SpanningTree <T> .Edge edge in node.edges)
{
if (edge.target.connected)
{
continue;
}
intrusiveMinHeap.Add(edge);
}
node.connected = true;
while (!intrusiveMinHeap.Empty)
{
SpanningTree <T> .Edge edge1 = intrusiveMinHeap.Pop();
SpanningTree <T> .Node node1 = edge1.target;
if (node1.connected)
{
continue;
}
node1.connected = true;
foreach (SpanningTree <T> .Edge edge2 in node1.edges)
{
if (edge2.target == edge1.source)
{
edge1 = edge2;
}
if (edge2.target.connected)
{
continue;
}
intrusiveMinHeap.Add(edge2);
}
this.edges.Add(edge1);
}
}
}
private void UpdateTouchOrder()
{
if (_touchTracker.SpanningTreeCount == 0)
{
_touchOrder.Clear();
return;
}
// mark all trackers as unused
for (int i = 0; i < _touchOrder.Count; i++)
{
SetTouchOrderTree(i, -1);
}
// find the trackers for each cluster and set the correct tree index
for (int i = 0; i < _touchTracker.SpanningTreeCount; i++)
{
SpanningTree tree = _touchTracker.GetSpanningTree(i);
int index = TouchOrderFindIndex(tree.GetActiveTouchId());
if (index != -1)
{
// Set current tree index for this touch id
SetTouchOrderTree(index, i);
}
else
{
// Add new tree to end of order
_touchOrder.Add(new TouchOrder
{
FingerId = tree.GetActiveTouchId(),
TreeIndex = i
});
}
}
// Remove any trackers that no longer have trees associated.
for (int i = _touchOrder.Count - 1; i >= 0; i--)
{
if (_touchOrder[i].TreeIndex == -1)
{
_touchOrder.RemoveAt(i);
}
}
}
public void test_kruskal()
{
Graph g = g1();
SpanningTreeInfo s = SpanningTree.GetSpanning(g);
Assert.AreEqual(16, s.cost);
Graph mg = mstGraph();
SpanningTreeInfo mst = SpanningTree.GetSpanning(mg);
Assert.AreEqual(10, mst.cost);
// Test for listing edges
/* foreach(Edge e in mst.edges) */
/* { */
/* Console.WriteLine("From {0} to {1} with cost {2}", */
/* e.source, e.destination, e.weight); */
/* } */
/* Assert.True(false); */
}
public void IntegrationTest()
{
var graph = GraphGenerator.GenerateGraph(10000, 500000, 1, 400);
var stopwatch = new Stopwatch();
stopwatch.Start();
var boruvka = SpanningTree.Boruvka(graph);
stopwatch.Stop();
Debug.WriteLine(stopwatch.ElapsedTicks);
stopwatch.Restart();
var kruskal = SpanningTree.Kruskal(graph);
stopwatch.Stop();
Debug.WriteLine(stopwatch.ElapsedTicks);
Assert.AreEqual(boruvka.Weight, kruskal.Weight);
}
private void ComputeDisplayEdges(SpanningTree.Node current, SpanningTree tree)
{
if (current == null)
{
return;
}
TouchPt touch = tree.GetTouchPoint(current);
Vector2 pos;
RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)transform, touch.position,
Camera.main, out pos);
_lines.Add(pos);
foreach (var neighbor in current.Neighbors)
{
ComputeDisplayEdges(neighbor, tree);
_lines.Add(pos);
}
}
public void Simple()
{
BasicBlock.clearIndexCounter();
var cfg = GenerateCFG(
@"
{
a = 3;
b = 2;
c = a + b;
}
");
var spanningTree = new SpanningTree(cfg);
var actual = spanningTree.dfst;
var expected = new List <IndexEdge>()
{
new IndexEdge(1, 0),
new IndexEdge(0, 2)
};
Assert.AreEqual(expected, actual);
}
/// <summary> Returns a ringset containing all rings in the given AtomContainer
///
/// </summary>
/// <param name="atomContainer"> The AtomContainer to be searched for rings
/// </param>
/// <returns> A RingSet with all rings in the AtomContainer
/// </returns>
/// <exception cref="CDKException"> An exception thrown if something goes wrong or if the timeout limit is reached
/// </exception>
public virtual IRingSet findAllRings(IAtomContainer atomContainer)
{
startTime = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
SpanningTree spanningTree;
try
{
spanningTree = new SpanningTree((IAtomContainer)atomContainer.Clone());
}
//UPGRADE_NOTE: Exception 'java.lang.CloneNotSupportedException' was converted to 'System.Exception' which has different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1100'"
catch (System.Exception e)
{
throw new CDKException("Could not clone IAtomContainer!", e);
}
spanningTree.identifyBonds();
if (spanningTree.BondsCyclicCount < 37)
{
findAllRings(atomContainer, false);
}
return(findAllRings(atomContainer, true));
}
private static List <IBond> GetSplitableBonds(IAtomContainer atomContainer)
{
// do ring detection
var spanningTree = new SpanningTree(atomContainer);
var allRings = spanningTree.GetAllRings();
// find the splitable bonds
List <IBond> splitableBonds = new List <IBond>();
foreach (var bond in atomContainer.Bonds)
{
bool isInRing = false;
bool isTerminal = false;
// lets see if it's in a ring
var rings = allRings.GetRings(bond);
if (rings.Any())
{
isInRing = true;
}
// lets see if it is a terminal bond
foreach (var atom in bond.Atoms)
{
if (atomContainer.GetConnectedBonds(atom).Count() == 1)
{
isTerminal = true;
break;
}
}
if (!(isInRing || isTerminal))
{
splitableBonds.Add(bond);
}
}
return(splitableBonds);
}
// Use this for initialization
void Start()
{
DT = new DelaunayTriangles(new Rect(0,0,128,64));
DT.VertexList.Add(new Vertex(3,6));
DT.VertexList.Add(new Vertex(34, 21));
DT.VertexList.Add(new Vertex(10, 15));
DT.VertexList.Add(new Vertex(98, 62));
DT.VertexList.Add(new Vertex(73, 21));
for (int i = 0; i < 20; i++) {
float x = Random.Range(0, 128);
float y = Random.Range(0, 64);
DT.VertexList.Add(new Vertex(x,y));
}
List<Node> nodes = new List<Node>();
foreach (Vertex v in DT.VertexList) {
//sp.transform.position = v.Position;
GameObject obj = GameObject.Instantiate(sp);
obj.transform.position = v.Position;
obj.SetActive(true);
nodes.Add(new Node(v.Position));
}
DT.DelaunayTrianglation();
//DT.DelaunayTrianglation();
//Debug.Log(DT.RootTriangle.ToString());
List<Edge> edges = new List<Edge>();
foreach (Triangle t in DT.TriangleSet.Keys) {
Node n1 = nodes.Find(n => n.Position.Equals(t.V1.Position));
Node n2 = nodes.Find(n => n.Position.Equals(t.V2.Position));
Node n3 = nodes.Find(n => n.Position.Equals(t.V3.Position));
edges.Add(new Edge(n1, n2, (n1.Position - n2.Position).sqrMagnitude));
edges.Add(new Edge(n2, n3, (n2.Position - n3.Position).sqrMagnitude));
edges.Add(new Edge(n3, n1, (n3.Position - n1.Position).sqrMagnitude));
}
SpanningTree spt = new SpanningTree(nodes.ToArray(),edges.ToArray());
spt.createTree(0);
Spt = spt;
}
public void Complex()
{
BasicBlock.clearIndexCounter();
var cfg = GenerateCFG(
@"
{
a = 3;
if t
{
a = a;
while (true)
{
d = c;
}
}
else
{
b = b;
}
}
");
var spanningTree = new SpanningTree(cfg);
var actual = spanningTree.dfst;
var expected = new List <IndexEdge>()
{
new IndexEdge(8, 0),
new IndexEdge(0, 2),
new IndexEdge(2, 3),
new IndexEdge(3, 5),
new IndexEdge(3, 4),
new IndexEdge(4, 6),
new IndexEdge(6, 7),
new IndexEdge(7, 9),
new IndexEdge(0, 1)
};
Assert.AreEqual(expected, actual);
}
private static void Main()
{
Console.WriteLine("\nTask 3.1 Edges~=1/10*Vertexes^2");
for (var i = 1; i < 1e4 + 1; i += 100)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateGraph(i, i * (i - 1) / 10, 1, (int)1e6);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.1 Full Graph");
for (var i = 1; i < 1e4 + 1; i += 100)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateFullGraph(i, 1, (int)1e6);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.2 Edges=100*Vertexes");
for (var i = 201; i < 1e4 + 1; i += 100)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateGraph(i, 100 * i, 1, (int)1e6);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.2 Edges=1000*Vertexes");
for (var i = 3001; i < 1e4 + 1; i += 100)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateGraph(i, 1000 * i, 1, (int)1e6);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.3");
for (var i = (int)1e5; i < 1e7; i += (int)1e5)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateGraph((int)(1e4) + 1, i, 1, (int)1e6);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.4 Full Graph");
for (var i = 1; i <= 200; i++)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateFullGraph((int)(1e4) + 1, 1, i);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
Console.WriteLine("\nTask 3.4 Edges = 1000 * Vertexes");
for (var i = 1; i <= 200; i++)
{
var stopWatch = new Stopwatch();
var graph = GraphGenerator.GenerateGraph((int)(1e4) + 1, (int)1e7, 1, i);
stopWatch.Restart();
var boruvkaSpanningTree = SpanningTree.Boruvka(graph);
stopWatch.Stop();
var burovkaTime = stopWatch.ElapsedTicks;
stopWatch.Restart();
var kruskalSpanningTree = SpanningTree.Kruskal(graph);
stopWatch.Stop();
var kruskalTime = stopWatch.ElapsedTicks;
var kruskalWeight = kruskalSpanningTree.Weight;
var burovkaWeight = boruvkaSpanningTree.Weight;
var testResult = new TestResult {
Edges = graph.Edges.Count,
Vertexes = graph.Vertexes.Count,
WeightsMatched = burovkaWeight == kruskalWeight ? "Passed" : "Failed",
BurovkaTime = burovkaTime, KruskalTime = kruskalTime
};
Console.WriteLine(testResult);
}
}
/// <summary>
/// The method calculates the number of rotatable bonds of an atom container.
/// If the boolean parameter is set to <see langword="true"/>, terminal bonds are included.
/// </summary>
/// <returns>number of rotatable bonds</returns>
/// <param name="includeTerminals"><see langword="true"/> if terminal bonds are included</param>
/// <param name="excludeAmides"><see langword="true"/> if amide C-N bonds should be excluded</param>
public Result Calculate(IAtomContainer container, bool includeTerminals = false, bool excludeAmides = false)
{
container = (IAtomContainer)container.Clone();
IRingSet ringSet;
try
{
ringSet = new SpanningTree(container).GetBasicRings();
}
catch (NoSuchAtomException)
{
return(new Result(0));
}
foreach (var bond in container.Bonds)
{
if (ringSet.GetRings(bond).Count() > 0)
{
bond.IsInRing = true;
}
}
int rotatableBondsCount = 0;
foreach (var bond in container.Bonds)
{
var atom0 = bond.Atoms[0];
var atom1 = bond.Atoms[1];
if (atom0.AtomicNumber.Equals(AtomicNumbers.H) || atom1.AtomicNumber.Equals(AtomicNumbers.H))
{
continue;
}
if (bond.Order == BondOrder.Single)
{
if (BondManipulator.IsLowerOrder(container.GetMaximumBondOrder(atom0), BondOrder.Triple) &&
BondManipulator.IsLowerOrder(container.GetMaximumBondOrder(atom1), BondOrder.Triple))
{
if (!bond.IsInRing)
{
if (excludeAmides && (IsAmide(atom0, atom1, container) || IsAmide(atom1, atom0, container)))
{
continue;
}
// if there are explicit H's we should ignore those bonds
var degree0 = container.GetConnectedBonds(atom0).Count() - GetConnectedHCount(container, atom0);
var degree1 = container.GetConnectedBonds(atom1).Count() - GetConnectedHCount(container, atom1);
if ((degree0 == 1) || (degree1 == 1))
{
if (includeTerminals)
{
rotatableBondsCount += 1;
}
}
else
{
rotatableBondsCount += 1;
}
}
}
}
}
return(new Result(rotatableBondsCount));
}
private void ProcessInput()
{
if (RendererPrefab != null)
{
if (_touchList.Count > 0)
{
if (_currentTrees.Count == 0)
{
SpanningTree newTree = SpanningTree.Get();
newTree.SetTouchList(_touchList);
if (newTree.SeparateClusters(_currentTrees))
{
newTree.Dispose();
}
}
else
{
foreach (var tree in _currentTrees)
{
// UpdateTouchPoints returns zero if the tree has been emptied of all touch points
// SeparateClusters adds either tree, or the results of the split trees into _tempTrees
// and returns true if the tree was split
if (tree.UpdateTouchPoints(_touchList) == 0 || tree.SeparateClusters(_tempTrees))
{
tree.Dispose();
}
}
// Swap tree lists, making the result of the update the _currentTrees
var temp = _currentTrees;
_currentTrees = _tempTrees;
_tempTrees = temp;
// clear the _tempTrees list
// Any trees that are not current have already been disposed
_tempTrees.Clear();
// Any touches left in _touchList are ones that are new
foreach (var touch in _touchList)
{
if (touch.phase == TouchPhase.Canceled || touch.phase == TouchPhase.Ended)
{
continue; // don't add old touches
}
// add any new touches into the closest tree
// but only if the distance is less than the maximum edge length
float bestDistance = MultiselectEventSystem.current.MaxTouchClusterDistancePixels;
SpanningTree tree = null;
foreach (var spanningTree in _currentTrees)
{
float treeDistance = spanningTree.ComputeMinimumDistanceToPoint(touch.position);
if (treeDistance < bestDistance)
{
bestDistance = treeDistance;
tree = spanningTree;
}
}
if (tree != null)
{
tree.AddTouch(touch);
tree.ProcessTree();
}
else
{
// Too far from any tree, create a new one
tree = SpanningTree.Get();
tree.AddTouch(touch);
_currentTrees.Add(tree);
}
}
}
EnsureRenderers(_currentTrees.Count);
for (int i = 0; i < _currentTrees.Count; i++)
{
DisplayTreeInRenderer(_renderers[i], _currentTrees[i]);
_renderers[i].gameObject.SetActive(true);
}
}
else
{
ReleaseTrees(_currentTrees);
}
for (int i = _currentTrees.Count; i < _renderers.Count; i++)
{
_renderers[i].gameObject.SetActive(false);
}
}
EnsurePointMarkers(_pointList.Count);
RectTransform rcTransform = (RectTransform)transform;
Vector2 offset = rcTransform.localPosition.XY();
for (int i = 0; i < _pointList.Count; i++)
{
TouchPt touch = _pointList[i];
Vector2 pos;
if (TouchCanvas.renderMode == RenderMode.ScreenSpaceOverlay)
{
pos = touch.position - offset;
}
else
{
RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)transform, touch.position,
TouchCanvas.worldCamera, out pos);
}
_pointMarkers[i].transform.localPosition = pos.AsVector3();
_pointMarkers[i].color = touch.phase == TouchPhase.Ended
? TouchEnded
: touch.phase == TouchPhase.Canceled ? TouchCancelled : TouchActive;
}
}
public void AddEdge(int a_idx, int b_idx, int cost, T value)
{
SpanningTree <T> .Node item = this.nodes[a_idx];
SpanningTree <T> .Node node = this.nodes[b_idx];
item.edges.Add(new SpanningTree <T> .Edge(item, node, cost, value));
}
public void createMapGraph(List<RoomArea> roomareas,float edgerelocationrate)
{
if (roomareas.Count == 0) {
Debug.LogAssertion("Empty RoomAreas.");
throw new ArgumentException();
}
//Vector2 upperlimit = AverageRoomSize * 100f;
List<Vertex> vertexs = new List<Vertex>();
foreach (RoomArea area in roomareas) {
Vertex v = new Vertex(area.CenterToInt);
vertexs.Add(v);
}
Debug.Log("v: "+vertexs.Count);
List<Node> nodes = new List<Node>();
List<Edge> edges = new List<Edge>();
DelaunayTriangles dt = new DelaunayTriangles(new Rect(Vector2.zero, MaxMapSize), vertexs);
if (vertexs.Count >= 3)
{
dt.DelaunayTrianglation();
nodes = Node.createNodes(new List<Triangle>(dt.TriangleSet.Keys).ToArray());
edges = Edge.createEdges(new List<Triangle>(dt.TriangleSet.Keys).ToArray());
//Debug.Log(string.Format("N:{0},E:{1}", nodes.Count, edges.Count));
}
else{
Debug.Log("Vertex amount lower than 3!!!");
foreach (Vertex v in vertexs) {
nodes.Add(new Node(v.Position));
}
Node n1 = nodes[0];
Node n2 = nodes[nodes.Count - 1];
float cost = (n1.Position - n2.Position).sqrMagnitude;
edges.Add(new Edge(n1,n2,cost));
}
SpanningTree spt = new SpanningTree(nodes.ToArray(), edges.ToArray());
Debug.LogFormat("N:{0},E:{1}",nodes.Count,edges.Count);
//Debug.Log("Create Tree");
spt.createTree(0);
//Debug.Log("Create Tree End");
////Debug.Log("After: " + RoomAreas.Count);
var es = new List<Edge>(spt.NewEdgeList);
edges.RemoveAll(e => spt.NewEdgeList.Contains(e));
////Debug.Log("Edgecount: " + edges.Count);
int limit = (int)(edges.Count * edgerelocationrate);
////Debug.Log("Limit: "+limit+","+edgerelocationrate);
for (int i = 0; i < limit; i++)
{
//////Debug.Log("Edgecount: "+edges.Count);
Edge adding = edges[GameController.Rnd.Next(edges.Count)];
es.Add(adding);
edges.Remove(adding);
if (edges.Count == 0) break;
}
//es.Distinct();
Mapgraph = new MapGraph(spt.NewNodeList, es,dt,spt,roomareas);
}
void createMapGraph(List<RoomArea> roomareas, float edgerelocationrate)
{
Debug.logger.logEnabled = false;
//Vector2 upperlimit = AverageRoomSize * 100f;
List<Vertex> vertexs = new List<Vertex>();
foreach (RoomArea area in roomareas)
{
Vertex v = new Vertex(area.CenterToInt);
vertexs.Add(v);
}
Debug.logger.LogFormat(LogType.Log,"v:{0} A:{1}",vertexs.Count,roomareas.Count);
List<Node> nodes = new List<Node>();
List<Edge> edges = new List<Edge>();
DelaunayTriangles dt = new DelaunayTriangles(new Rect(Vector2.zero, DgParam.MaxMapSize), vertexs);
if (vertexs.Count > 3)
{
dt.DelaunayTrianglation();
nodes = Node.createNodes(new List<Triangle>(dt.TriangleSet.Keys).ToArray());
edges = Edge.createEdges(new List<Triangle>(dt.TriangleSet.Keys).ToArray());
//Debug.Log(string.Format("N:{0},E:{1}", nodes.Count, edges.Count));
}
else
{
Debug.Log("Vertex amount lower than 3!!!");
List<Node> ns = new List<Node>();
List<Node> select = new List<Node>();
List<Edge> eds = new List<Edge>();
vertexs.ForEach(v => ns.Add(new Node(v.Position)));
int maxcount = Mathf.Max(0,ns.Count - 1);
for (int i = 0; i < maxcount; i++) {
var rest = ns.FindAll(n=> !select.Contains(n));
var sel = rest[Rnd.Next(rest.Count)];
select.Add(sel);
}
var rest2 = ns.FindAll(n => !select.Contains(n));
rest2.ForEach(s2 => {
select.ForEach(s1 =>
{
eds.Add(new Edge(s2,s1,(s1.Position-s2.Position).sqrMagnitude ));
});
});
nodes = ns;
edges = eds;
}
var restv = vertexs.FindAll( v => nodes.Find(n => n.Position.Equals(v.Position))==null);
Debug.logger.LogFormat(LogType.Warning,"Rest Vertex:{0}", restv.Count());
if (restv.Count != 0) {
restv.ForEach(v => {
var n1 = new Node(v.Position);
var n2 = nodes[Rnd.Next(nodes.Count)];
nodes.Add(n1);
edges.Add(new Edge(n1,n2,(n1.Position - n2.Position).sqrMagnitude));
});
}
SpanningTree spt = new SpanningTree(nodes.ToArray(), edges.ToArray());
Debug.logger.LogFormat(LogType.Log,"N:{0},E:{1}", nodes.Count, edges.Count);
//Debug.Log("Create Tree");
spt.createTree(0);
//Debug.Log("Create Tree End");
////Debug.Log("After: " + RoomAreas.Count);
var es = new List<Edge>(spt.NewEdgeList);
edges.RemoveAll(e => spt.NewEdgeList.Contains(e));
////Debug.Log("Edgecount: " + edges.Count);
int limit = (int)(edges.Count * edgerelocationrate);
////Debug.Log("Limit: "+limit+","+edgerelocationrate);
for (int i = 0; i < limit; i++)
{
//////Debug.Log("Edgecount: "+edges.Count);
Edge adding = edges[Rnd.Next(edges.Count)];
es.Add(adding);
edges.Remove(adding);
if (edges.Count == 0) break;
}
//es.Distinct();
Mapgraph = new MapGraph(spt.NewNodeList, es, dt, spt, roomareas);
Debug.logger.logEnabled = true;
}
