public static DynamicPlotter GetDynamicPlotter(DynamicPlotData data) { var plotter = new GameObject().AddComponent <DynamicPlotter>(); var graph = new DynamicGraph(); data.Points.ForEach(point => graph.AddPlotPoint(new PlotPoint(point.XColumn, point.YColumn, point.ZColumn)) ); graph.AddTimePoints(data.TimeColumn); plotter.Graph = graph; plotter.PointHolder = GetPlotHolder(); plotter.PointPrefab = data.PointObject.transform; plotter.Text = GetText3D(); plotter.PlotTitle = data.Title; plotter.XAxisName = data.XName; plotter.YAxisName = data.YName; plotter.ZAxisName = data.ZName; plotter.PlotScale = data.PlotScale; plotter.Init(); return(plotter); }
public static void wikipedia_graph_sample() { var nodes = new[] { 1, 2, 3, 4, 5, 6 }; var edges = new Dictionary <DualKey <int>, double> { { new DualKey <int>(1, 2), 7 }, { new DualKey <int>(1, 3), 9 }, { new DualKey <int>(1, 6), 14 }, { new DualKey <int>(2, 3), 10 }, { new DualKey <int>(2, 4), 15 }, { new DualKey <int>(3, 4), 11 }, { new DualKey <int>(3, 6), 2 }, { new DualKey <int>(4, 5), 6 }, { new DualKey <int>(5, 6), 9 } }; // add the reverse edges foreach (var reversedEdgeData in edges.Select(x => new { Key = new DualKey <int>(x.Key.B, x.Key.A), x.Value }).ToList()) { edges.Add(reversedEdgeData.Key, reversedEdgeData.Value); } var result = DynamicGraph.FindPath( 1, 5, (int node, double curCost) => edges .Where(x => x.Key.A == node) .Select(edge => new DynamicGraphNodeData <int, double, KeyValuePair <DualKey <int>, double> >(edge.Key.B, curCost + edge.Value, edge)) ); result.Select(x => x.Node).Should().Equal(new[] { 1, 3, 6, 5 }); //Assert.AreEqual(new[] { 1, 3, 6, 5 }, result.Select(x => x.Node).ToArray()); result.Last().Cost.Should().Be(20); //Assert.AreEqual(20, result.Last().Cost); }
public DiagramSettingsView(DynamicGraph dGraph) { this.GSettings = new GraphSettings(); this.Graph = dGraph; this.Graph.Settings = this.GSettings; }
/// <summary> /// Finds a path through all the given transformations and determines the required to and from types for each transformation. /// </summary> /// <param name="transformations">The transformations to find a casting path between.</param> /// <param name="startType">The from type of the first transformation.</param> /// <param name="endType">The to type of the last transformation.</param> /// <returns>Transformation nodes providing cast information for a path from start to finish.</returns> public static TransformationCastNode[] FindCastPath(IList <ITransformation> transformations, Type startType, Type endType) { if (null == transformations) { throw new ArgumentNullException("transformations"); } if (null == startType) { throw new ArgumentNullException("startType"); } if (null == endType) { throw new ArgumentNullException("endType"); } if (transformations.Any(x => null == x)) { throw new ArgumentException("transformations must all be non-null", "transformations"); } Contract.EndContractBlock(); if (transformations.Count == 0) { return(null); // NO DATA } // determine the valid start nodes Contract.Assume(transformations[0] != null); var startNodes = GenerateNodes(transformations[0]) .Where(x => x.FromType == startType) .ToArray(); Contract.Assume(Contract.ForAll(startNodes, x => x != null)); // if there is only one transformation, just use that if (transformations.Count == 1) { var selectedTx = startNodes.FirstOrDefault(x => x.ToType == endType); return(null != selectedTx ? new[] { selectedTx } : null); } // build the edges and nodes between the start and end types var previousNodes = startNodes; var edges = new Dictionary <TransformationCastNode, List <TransformationCastNode> >(); for (int i = 1; i < transformations.Count; i++) { Contract.Assume(transformations[i] != null); var currentNodes = GenerateNodes(transformations[i]).ToArray(); Contract.Assume(Contract.ForAll(currentNodes, x => x != null)); foreach (var priorNode in previousNodes) { foreach (var curNode in currentNodes) { if (priorNode.ToType == curNode.FromType) { List <TransformationCastNode> edgeData; if (!edges.TryGetValue(priorNode, out edgeData)) { edgeData = new List <TransformationCastNode>(); edges.Add(priorNode, edgeData); } Contract.Assume(edgeData != null); edgeData.Add(curNode); } } } previousNodes = currentNodes; } // the end types are the last nodes that have matching end types var endNodes = previousNodes.Where(x => x.ToType == endType).ToArray(); // the neighborhood GetDynamicGraphNeighborInfo <TransformationCastNode, int, TransformationCastNode> getNeighborhood = (node, curCost) => { List <TransformationCastNode> edgeData; edges.TryGetValue(node, out edgeData); return((edgeData ?? Enumerable.Empty <TransformationCastNode>()).Select(x => new DynamicGraphNodeData <TransformationCastNode, int, TransformationCastNode>(x, curCost + 1, x))); }; // go through each combination of start and end types until something is found foreach (var startNode in startNodes) { foreach (var endNode in endNodes) { Contract.Assume(endNode != null); // because GenerateNodes will not return a null element var result = DynamicGraph.FindPath(startNode, endNode, getNeighborhood); if (null != result) { return(result.Select(x => x.Node).ToArray()); // OK! } } } return(null); // no path found }