public override void Compute(CircleNodeScene scene)
        {
            this.mAlg = a(scene);
            this.mAlg.Compute();
            int i;

            Digraph <CircleNode, ArrowEdge> .GEdge[] edges
                = scene.Graph.InternalEdges;
            for (i = 0; i < edges.Length; i++)
            {
                edges[i].Data.LineDashStyle = DashStyle.Solid;
            }
            edges = this.mAlg.SpanningTree.InternalEdges;
            for (i = 0; i < edges.Length; i++)
            {
                edges[i].Data.LineDashStyle = DashStyle.Dash;
            }
        }
示例#2
0
        protected override void PerformPrecalculations(
            uint lastNodeVersion, uint lastEdgeVersion)
        {
            if (this.bSpanTreeDirty)
            {
                ISpanningTreeAlgorithm <Node, Edge> alg = null;
                switch (this.mSpanTreeGen)
                {
                case SpanningTreeGen.BFS:
                    BFSpanningTree <Node, Edge> bfst
                        = new BFSpanningTree <Node, Edge>(
                              this.mGraph, false, false);
                    bfst.RootCapacity = this.RootCount;
                    Digraph <Node, Edge> .GNode r1;
                    for (int i = this.RootCount - 1; i >= 0; i--)
                    {
                        r1 = this.RootAt(i);
                        bfst.AddRoot(r1.Index);
                    }
                    this.mSpanTreeAlg = bfst;
                    break;

                case SpanningTreeGen.DFS:
                    DFSpanningTree <Node, Edge> dfst
                        = new DFSpanningTree <Node, Edge>(
                              this.mGraph, false, false);
                    dfst.RootCapacity = this.RootCount;
                    Digraph <Node, Edge> .GNode r2;
                    for (int j = this.RootCount - 1; j >= 0; j--)
                    {
                        r2 = this.RootAt(j);
                        dfst.AddRoot(r2.Index);
                    }
                    this.mSpanTreeAlg = dfst;
                    break;

                case SpanningTreeGen.Boruvka:
                    this.mSpanTreeAlg
                        = new BoruvkaMinSpanningTree <Node, Edge>(mGraph);
                    break;

                case SpanningTreeGen.Kruskal:
                    this.mSpanTreeAlg
                        = new KruskalMinSpanningTree <Node, Edge>(mGraph);
                    break;

                case SpanningTreeGen.Prim:
                    this.mSpanTreeAlg
                        = new PrimMinSpanningTree <Node, Edge>(mGraph);
                    break;
                }
            }
            if (this.bSpanTreeDirty ||
                lastNodeVersion != this.mGraph.NodeVersion ||
                lastEdgeVersion != this.mGraph.EdgeVersion)
            {
                this.mSpanTreeAlg.Reset();
                this.mSpanTreeAlg.Compute();
                this.mSpanTreeEdges = this.mSpanTreeAlg.SpanningTreeEdges;
                this.mSTECount      = this.mSpanTreeEdges.Length;
                this.bDataTreeDirty = true;
            }
            if (this.bDataTreeDirty)
            {
                this.BuildDataTree();
            }
            this.PerformTreePrecalculations(this.mDataTree,
                                            lastNodeVersion, lastEdgeVersion);
            this.bSpanTreeDirty = false;
            this.bDataTreeDirty = false;
        }