public void UpdateLayer(List <DAG.Node> layer, DAG.Direction direction)
{
List <InvariantList> nodeInvariantList = new List <InvariantList>();
for (int i = 0; i < layer.Count; i++)
{
DAG.Node layerNode = layer[i];
int x = layerNode.vertexIndex;
InvariantList nodeInvariant =
new InvariantList(nodes.IndexOf(layerNode));
nodeInvariant.Add(this.invariants.GetColor(x));
nodeInvariant.Add(this.invariants.GetVertexInvariant(x));
List <int> relativeInvariants = new List <int>();
// If we go up we should check the children.
List <DAG.Node> relatives = (direction == Direction.Up) ?
layerNode.children : layerNode.parents;
foreach (var relative in relatives)
{
int j = this.nodes.IndexOf(relative);
int inv = this.invariants.GetNodeInvariant(j);
int edgeColor;
if (direction == Direction.Up)
{
edgeColor = relative.edgeColors[layerNode.vertexIndex];
}
else
{
edgeColor = layerNode.edgeColors[relative.vertexIndex];
}
relativeInvariants.Add(inv);
relativeInvariants.Add(vertexCount + 1 + edgeColor);
}
relativeInvariants.Sort();
nodeInvariant.AddAll(relativeInvariants);
nodeInvariantList.Add(nodeInvariant);
}
nodeInvariantList.Sort();
int order = 1;
int first = nodeInvariantList[0].originalIndex;
this.invariants.SetNodeInvariant(first, order);
for (int i = 1; i < nodeInvariantList.Count; i++)
{
InvariantList a = nodeInvariantList[i - 1];
InvariantList b = nodeInvariantList[i];
if (!a.Equals(b))
{
order++;
}
this.invariants.SetNodeInvariant(b.originalIndex, order);
}
}
public void UpdateNodeInvariants(DAG.Direction direction)
{
int start, end, increment;
if (direction == Direction.Up)
{
start = this.layers.Count - 1;
// The root node is not included but it doesn't matter since it
// is always alone.
end = -1;
increment = -1;
}
else
{
start = 0;
end = this.layers.Count;
increment = 1;
}
for (int i = start; i != end; i += increment)
{
this.UpdateLayer(this.layers[i], direction);
}
}
