public void EachEdge(EdgeAction del) { foreach (Connection e in graph.Connections) { del(e, GetSpring(e)); } }
protected virtual void GenerateSpanningTree(CancellationToken cancellationToken) { SpanningTree = new BidirectionalGraph <TVertex, Edge <TVertex> >(false); SpanningTree.AddVertexRange(VisitedGraph.Vertices.OrderBy(v => VisitedGraph.InDegree(v))); EdgeAction <TVertex, TEdge> action = e => { cancellationToken.ThrowIfCancellationRequested(); SpanningTree.AddEdge(new Edge <TVertex>(e.Source, e.Target)); }; switch (Parameters.SpanningTreeGeneration) { case SpanningTreeGeneration.BFS: var bfsAlgo = new BreadthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph); bfsAlgo.TreeEdge += action; bfsAlgo.Compute(); break; case SpanningTreeGeneration.DFS: var dfsAlgo = new DepthFirstSearchAlgorithm <TVertex, TEdge>(VisitedGraph); dfsAlgo.TreeEdge += action; dfsAlgo.ForwardOrCrossEdge += action; dfsAlgo.Compute(); break; } }
public void EachEdge(EdgeAction del) { foreach (var e in Graph.Edges) { del(e, GetSpring(e)); } }
public MovingSprite(Texture2D texture, Vector2 position, SpriteEffects effects, double timeBetweenUpdates, Vector2 speed, EdgeAction edge) : base(texture, position, effects, timeBetweenUpdates) { this.spd = speed; this.edge = edge; }
public void EachEdge(EdgeAction del) { foreach (Edge e in graph.edges) { del(e, GetSpring(e)); } }
public Edge(GraphNode one, GraphNode two, EdgeAction action, float cost, Vector3 position) { m_position = position; m_NodeOne = one; m_NodeTwo = two; m_edgeAction = action; m_traversalCost = cost; }
public Node(EdgeAction action) { d_action = action; if (d_action != null) { d_action.AddNotification("target", OnActionChanged); d_action.AddNotification("equation", OnActionChanged); } }
/// <inheritdoc /> public bool HideEdge(TEdge edge, string tag) { HiddenCollection collection = GetHiddenCollection(tag); var hideEdgeHandler = new EdgeAction <TVertex, TEdge>(e => collection.HiddenEdges.Add(e)); EdgeHidden += hideEdgeHandler; bool hidden = HideEdge(edge); EdgeHidden -= hideEdgeHandler; return(hidden); }
public bool HideEdge(TEdge e, string tag) { var h = GetHiddenCollection(tag); var eeh = new EdgeAction <TVertex, TEdge>(edge => h.hiddenEdges.Add(edge)); EdgeHidden += eeh; bool ret = HideEdge(e); EdgeHidden -= eeh; return(ret); }
public SpriteBase() { txtre = null; pstn = new Rectangle(0, 0, 0, 0); cllsn = new Rectangle(0, 0, 0, 0); tnt = Color.White; fx = SpriteEffects.None; eg = EdgeAction.Stop; lstfrme = 20; msprfrme = 20; tnt = Color.White; spd = new Vector2(0, 0); alive = true; }
public bool HideVertex(TVertex v, string tag) { HiddenCollection h = GetHiddenCollection(tag); var eeh = new EdgeAction <TVertex, TEdge>(e => h.hiddenEdges.Add(e)); var veh = new VertexAction <TVertex>(vertex => h.hiddenVertices.Add(vertex)); EdgeHidden += eeh; VertexHidden += veh; bool ret = HideVertex(v); EdgeHidden -= eeh; VertexHidden -= veh; return(ret); }
/// <inheritdoc /> public bool HideVertex(TVertex vertex, string tag) { HiddenCollection collection = GetHiddenCollection(tag); var hideEdgeHandler = new EdgeAction <TVertex, TEdge>(e => collection.HiddenEdges.Add(e)); var hideVertexHandler = new VertexAction <TVertex>(v => collection.HiddenVertices.Add(v)); EdgeHidden += hideEdgeHandler; VertexHidden += hideVertexHandler; bool hidden = HideVertex(vertex); EdgeHidden -= hideEdgeHandler; VertexHidden -= hideVertexHandler; return(hidden); }
public SpriteBase(Texture2D txtre, Rectangle pstn, Vector2 spd, double msprfrme, Color tnt, SpriteEffects fx) { this.txtre = txtre; this.pstn = pstn; this.spd = spd; this.msprfrme = msprfrme; //this.crntfrme = crntfrme; this.tnt = tnt; this.fx = fx; this.eg = EdgeAction.Stop; src = new Rectangle(0, 0, txtre.Width, txtre.Height); cllsn = new Rectangle(0, 0, 0, 0); cllsn.X = pstn.X; cllsn.Y = pstn.Y; cllsn.Width = pstn.Width; cllsn.Height = pstn.Height; this.alive = true; }
private bool HasCycles(IVertexListGraph <IBuilder, EquatableEdge <IBuilder> > graph) { var dfs = new DepthFirstSearchAlgorithm <IBuilder, EquatableEdge <IBuilder> >(graph); Boolean isDag = true; EdgeAction <IBuilder, EquatableEdge <IBuilder> > onBackEdge = edge => { isDag = false; log.DebugFormat("Back edge: {0} -> {1}", edge.Source, edge.Target); }; try { dfs.BackEdge += onBackEdge; dfs.Compute(); } finally { dfs.BackEdge -= onBackEdge; } return(!isDag); }
protected void PrepareForSugiyama() { MinimizeHierarchicalEdgeLong(); #region 1) Unhide general edges between vertices participating in the hierarchy var analyze = new HashSet <SugiVertex>(); EdgeAction <SugiVertex, SugiEdge> eeh = edge => { analyze.Add(edge.Source); analyze.Add(edge.Target); }; _graph.EdgeUnhidden += eeh; _graph.UnhideEdgesIf(e => e.Type == EdgeTypes.General && _graph.ContainsVertex(e.Source) && _graph.ContainsVertex(e.Target)); _graph.EdgeUnhidden -= eeh; #endregion #region 2) Move the vertices with general edges if possible foreach (var v in analyze) { //csak lejjebb lehet rakni //csak akkor, ha nincs hierarchikus kimeno el lefele //a legkozelebbi lehetseges szintre if (_graph.OutHierarchicalEdgeCount(v) == 0) { //az altalanos elek kozul az alattalevok kozul a legkozelebbibre kell rakni int newLayerIndex = _layers.Count; foreach (var e in _graph.InGeneralEdges(v)) { //nem erdemes tovabb folytatni, lejebb nem kerulhet if (newLayerIndex == v.LayerIndex) { break; } if (e.Source.LayerIndex >= v.LayerIndex && e.Source.LayerIndex < newLayerIndex) { newLayerIndex = e.Source.LayerIndex; } } foreach (var e in _graph.OutGeneralEdges(v)) { //nem erdemes tovabb folytatni, lejebb nem kerulhet if (newLayerIndex == v.LayerIndex) { break; } if (e.Target.LayerIndex >= v.LayerIndex && e.Target.LayerIndex < newLayerIndex) { newLayerIndex = e.Target.LayerIndex; } } if (newLayerIndex < _layers.Count) { _layers[v.LayerIndex].Remove(v); _layers[newLayerIndex].Add(v); } } } #endregion // 3) Hide the general edges between different layers _graph.HideEdgesIf(e => (e.Type == EdgeTypes.General && e.Source.LayerIndex != e.Target.LayerIndex), GeneralEdgesBetweenDifferentLayersTag); //replace long edges with more segments and dummy vertices ReplaceLongEdges(); ConstrainWidth(); CopyPositions(); OnIterationEnded("Preparation of the positions done."); }
internal void Update(EdgeAction edgeAction) { throw new NotImplementedException(); }
public MovingSprite() : base() { spd = new Vector2(0, 0); edge = EdgeAction.Stop; }
private void PromoteEdgeSlices() { // This function splits all the edge actions on variables based // on the slice on which the operate on the target variable. var cp = d_actionedVariables; d_actionedVariables = new Dictionary <Variable, EdgeAction[]>(); foreach (var pair in cp) { var variable = pair.Key; var actions = pair.Value; var split = SplitActionsPerSlice(actions); if (split.Count == 1) { // That's ok, no diversity means we can just use the // normal code path d_actionedVariables[pair.Key] = pair.Value; continue; } // Contains a set of instructions for each value in the matrix // representing the final, new equation. Each value in the matrix // is a set of instructions because it can be a sum List <Cdn.Instruction>[] instructions = new List <Instruction> [variable.Dimension.Size()]; // Ai! Cool stuff needs to happen here. Split out new // variables for these equations and setup a new edge action // representing the fully combined set. Complex you say? Indeed! foreach (var elem in split) { // Combine elements with the same indices by simply doing a sum var eqs = Array.ConvertAll <Cdn.EdgeAction, Cdn.Expression>(elem.ToArray(), a => a.Equation); Cdn.Expression sum = Cdn.Expression.Sum(eqs); // Now make a variable for it var nv = new Cdn.Variable(UniqueVariableName(variable.Object, String.Format("__d{0}", variable.Name)), sum, VariableFlags.None); variable.Object.AddVariable(nv); // Add relevant instructions as per slice var slice = elem[0].Indices; if (slice == null || slice.Length == 0) { // Empty slice is just the full range slice = new int[variable.Dimension.Size()]; for (int i = 0; i < slice.Length; ++i) { slice[i] = i; } } for (int i = 0; i < slice.Length; ++i) { if (instructions[slice[i]] == null) { instructions[slice[i]] = new List <Instruction>(); } var vinstr = new Cdn.InstructionVariable(nv); vinstr.SetSlice(new int[] { i }, new Cdn.Dimension { Rows = 1, Columns = 1 }); instructions[slice[i]].Add(vinstr); } } List <Cdn.Instruction> ret = new List <Instruction>(); // Create substitute edge action foreach (var i in instructions) { if (i == null) { ret.Add(new Cdn.InstructionNumber("0")); } else { // Add indexing instructions ret.AddRange(i); // Then add simple plus operators for (int j = 0; j < i.Count - 1; ++j) { ret.Add(new Cdn.InstructionFunction((uint)Cdn.MathFunctionType.Plus, null, 2)); } } } var minstr = new Cdn.InstructionMatrix(new Cdn.StackArgs(instructions.Length), variable.Dimension); ret.Add(minstr); var retex = new Cdn.Expression(""); retex.SetInstructionsTake(ret.ToArray()); var action = new Cdn.EdgeAction(variable.Name, retex); ((Cdn.Node)variable.Object).SelfEdge.AddAction(action); d_actionedVariables[variable] = new EdgeAction[] { action }; } }
private static Bitmap EdgeDetection(Bitmap Image, double Threshold, EdgeAction EdgeColor) { System.Drawing.Bitmap TempBitmap = Image; System.Drawing.Bitmap NewBitmap = new System.Drawing.Bitmap(TempBitmap.Width, TempBitmap.Height); System.Drawing.Graphics NewGraphics = Graphics.FromImage(NewBitmap); NewGraphics.DrawImage(TempBitmap, new System.Drawing.Rectangle(0, 0, TempBitmap.Width, TempBitmap.Height), new System.Drawing.Rectangle(0, 0, TempBitmap.Width, TempBitmap.Height), GraphicsUnit.Pixel); NewGraphics.Dispose(); for (int x = 0; x < NewBitmap.Width; ++x) { for (int y = 0; y < NewBitmap.Height; ++y) { bool EdgeSet = false; Color CurrentColor = NewBitmap.GetPixel(x, y); if (y < NewBitmap.Height - 1 && x < NewBitmap.Width - 1) { Color TempColor = NewBitmap.GetPixel(x + 1, y + 1); if (Math.Sqrt(((CurrentColor.R - TempColor.R) * (CurrentColor.R - TempColor.R)) + ((CurrentColor.G - TempColor.G) * (CurrentColor.G - TempColor.G)) + ((CurrentColor.B - TempColor.B) * (CurrentColor.B - TempColor.B))) > Threshold) { EdgeColor(x, y); } EdgeSet = true; } if (y < NewBitmap.Height - 1 && !EdgeSet) { Color TempColor = NewBitmap.GetPixel(x, y + 1); if (Math.Sqrt(((CurrentColor.R - TempColor.R) * (CurrentColor.R - TempColor.R)) + ((CurrentColor.G - TempColor.G) * (CurrentColor.G - TempColor.G)) + ((CurrentColor.B - TempColor.B) * (CurrentColor.B - TempColor.B))) > Threshold) { EdgeColor(x, y); // NewBitmap.SetPixel(x, y, EdgeColor); } EdgeSet = true; } if (x < NewBitmap.Width - 1 && !EdgeSet) { Color TempColor = NewBitmap.GetPixel(x + 1, y); if (Math.Sqrt(((CurrentColor.R - TempColor.R) * (CurrentColor.R - TempColor.R)) + ((CurrentColor.G - TempColor.G) * (CurrentColor.G - TempColor.G)) + ((CurrentColor.B - TempColor.B) * (CurrentColor.B - TempColor.B))) > Threshold) { EdgeColor(x, y); //NewBitmap.SetPixel(x, y, EdgeColor); } EdgeSet = true; } } } return NewBitmap; }