Ejemplo n.º 1
0
        Comparison <int> Comparison(Dictionary <int, int> inverseToOrder)
        {
            return(delegate(int node1, int node2) {
                Debug.Assert(properLayeredGraph.IsVirtualNode(node1) &&
                             properLayeredGraph.IsVirtualNode(node2));

                int succ1 = properLayeredGraph.Succ(node1).ElementAt(0);
                int succ2 = properLayeredGraph.Succ(node2).ElementAt(0);
                int pred1 = properLayeredGraph.Pred(node1).ElementAt(0);
                int pred2 = properLayeredGraph.Pred(node2).ElementAt(0);

                Point succPoint1 = nodePositions[succ1];
                Point succPoint2 = nodePositions[succ2];
                Point predPoint1 = nodePositions[pred1];
                Point predPoint2 = nodePositions[pred2];

                if (succPoint1 != succPoint2)
                {
                    if (predPoint1 != predPoint2)
                    {
                        return predPoint1.CompareTo(predPoint2);
                    }
                    return succPoint1.CompareTo(succPoint2);
                }
                if (properLayeredGraph.IsVirtualNode(succ1))
                {
                    if (predPoint1 != predPoint2)
                    {
                        return predPoint1.CompareTo(predPoint2);
                    }

                    int o1 = inverseToOrder[succ1];
                    int o2 = inverseToOrder[succ2];
                    Debug.Assert(o1 != -1 && o2 != -1);
                    return (o1.CompareTo(o2));
                }
                while (nodePositions[pred1] == nodePositions[pred2] &&
                       properLayeredGraph.IsVirtualNode(pred1))
                {
                    pred1 = properLayeredGraph.Pred(pred1).ElementAt(0);
                    pred2 = properLayeredGraph.Pred(pred2).ElementAt(0);
                }

                if (nodePositions[pred1] == nodePositions[pred2])
                {
                    return node1.CompareTo(node2);
                }
                return nodePositions[pred1].CompareTo(nodePositions[pred2]);
            });
        }
Ejemplo n.º 2
0
        static Dictionary <int, Point> BuildInitialNodePositions(ProperLayeredGraph properLayeredGraph,
                                                                 LayerArrays layerArrays)
        {
            var result = new Dictionary <int, Point>();

            for (int i = 0; i < layerArrays.Layers.Length; i++)
            {
                int prev = 0, curr = 0;
                while (curr < layerArrays.Layers[i].Length)
                {
                    while (curr < layerArrays.Layers[i].Length &&
                           properLayeredGraph.IsVirtualNode(layerArrays.Layers[i][curr]))
                    {
                        curr++;
                    }
                    for (int j = prev; j < curr; j++)
                    {
                        result[layerArrays.Layers[i][j]] = new Point(i, prev);
                    }

                    if (curr < layerArrays.Layers[i].Length)
                    {
                        result[layerArrays.Layers[i][curr]] = new Point(i, curr);
                    }
                    curr++;
                    prev = curr;
                }
            }

            return(result);
        }
        static Dictionary<int, Point> BuildInitialNodePositions(ProperLayeredGraph properLayeredGraph,
                                                                LayerArrays layerArrays) {
            var result = new Dictionary<int, Point>();
            for (int i = 0; i < layerArrays.Layers.Length; i++) {
                int prev = 0, curr = 0;
                while (curr < layerArrays.Layers[i].Length) {
                    while (curr < layerArrays.Layers[i].Length &&
                           properLayeredGraph.IsVirtualNode(layerArrays.Layers[i][curr])) curr++;
                    for (int j = prev; j < curr; j++)
                        result[layerArrays.Layers[i][j]] = new Point(i, prev);

                    if (curr < layerArrays.Layers[i].Length)
                        result[layerArrays.Layers[i][curr]] = new Point(i, curr);
                    curr++;
                    prev = curr;
                }
            }

            return result;
        }
 bool IsVirtualNode(int v)
 {
     return(properLayeredGraph.IsVirtualNode(v));
 }