void GenerateFromEvents(Solver solver, OverlapRemovalParameters parameters,
List<Event> events, bool isHorizontal)
{
// First, sort the events on the perpendicular coordinate of the event
// (e.g. for horizontal constraint generation, order on vertical position).
events.Sort();
#if VERBOSE
Console.WriteLine("Events:");
foreach (Event evt in events)
{
Console.WriteLine(" {0}", evt);
}
#endif // VERBOSE
var scanLine = new ScanLine();
foreach (Event evt in events)
{
OverlapRemovalNode currentNode = evt.Node;
if (evt.IsForOpen)
{
// Insert the current node into the scan line.
scanLine.Insert(currentNode);
#if VERBOSE
Console.WriteLine("ScanAdd: {0}", currentNode);
#endif // VERBOSE
// Find the nodes that are currently open to either side of it and are either overlapping
// nodes or the first non-overlapping node in that direction.
currentNode.LeftNeighbors = GetLeftNeighbours(parameters, scanLine, currentNode, isHorizontal);
currentNode.RightNeighbors = GetRightNeighbours(parameters, scanLine, currentNode, isHorizontal);
// Use counts for indexing for performance (rather than foreach, and hoist the count-control
// variable out of the loop so .Count isn't checked on each iteration, since we know it's
// not going to be changed).
int numLeftNeighbors = currentNode.LeftNeighbors.Count;
int numRightNeighbors = currentNode.RightNeighbors.Count;
// If there is currently a non-overlap constraint between any two nodes across the
// two neighbour lists we've just created, we can remove them because they will be
// transitively enforced by the constraints we'll create for the current node.
// I.e., we can remove the specification for the constraint
// leftNeighborNode + gap + padding <= rightNeighborNode
// because it is implied by the constraints we'll create for
// leftNeighborNode + gap + padding <= node
// node + gap + padding <= rightNeighborNode
// We must also add the current node as a neighbour in the appropriate direction.
// @@PERF: List<T>.Remove is a sequential search so averages 1/2 the size of the
// lists. We currently don't expect the neighbour lists to be very large or Remove
// to be a frequent operation, and using HashSets would incur the GetEnumerator overhead
// on the outer and inner loops; but .Remove creates an inner-inner loop so do some
// timing runs to compare performance.
// @@PERF: handles the case where we are node c and have added node b as a lnbour
// and node d as rnbour, where those nodes are already nbours. But it does not handle
// the case where we add node b and node a as lnbours, and node b already has node a
// as an lnbour. To do this I think we'd just want to skip adding the node-a lnbour,
// but that forms a new inner loop (iterating all lnbours before adding a new one)
// unless we develop different storage for nbours.
for (int ii = 0; ii < numLeftNeighbors; ++ii)
{
OverlapRemovalNode leftNeighborNode = currentNode.LeftNeighbors[ii];
for (int jj = 0; jj < numRightNeighbors; ++jj)
{ // TODOunit: test this
OverlapRemovalNode nodeToRemove = currentNode.RightNeighbors[jj];
if (leftNeighborNode.RightNeighbors.Remove(nodeToRemove))
{
#if VERBOSE
Console.WriteLine(" {0} RnbourRem {1} --> {2}", isHorizontal ? "H" : "V", leftNeighborNode, nodeToRemove);
#endif // VERBOSE
}
}
leftNeighborNode.RightNeighbors.Add(currentNode);
}
for (int ii = 0; ii < numRightNeighbors; ++ii)
{ // TODOunit: test this
OverlapRemovalNode rightNeighborNode = currentNode.RightNeighbors[ii];
for (int jj = 0; jj < numLeftNeighbors; ++jj)
{
OverlapRemovalNode nodeToRemove = currentNode.LeftNeighbors[jj];
if (rightNeighborNode.LeftNeighbors.Remove(nodeToRemove))
{
#if VERBOSE
Console.WriteLine(" {0} LnbourRem {1} --> {2}", isHorizontal ? "H" : "V", nodeToRemove, rightNeighborNode);
#endif // VERBOSE
}
}
rightNeighborNode.LeftNeighbors.Add(currentNode);
}
} // endif evt.IsForOpen
else
{
// This is a close event, so generate the constraints and remove the closing node
// from its neighbours lists. If we're closing we should have left neighbours so
// this is null then we've likely got some sort of internal calculation error.
if (null == currentNode.LeftNeighbors)
{
Debug.Assert(null != currentNode.LeftNeighbors, "LeftNeighbors should not be null for a Close event");
continue;
}
// currentNode is the current node; if it's a cluster, translate it to the node that
// should be involved in the constraint (if it's the left neighbour then use its
// right border as the constraint variable, and vice-versa).
OverlapRemovalNode currentLeftNode = GetLeftConstraintNode(currentNode);
OverlapRemovalNode currentRightNode = GetRightConstraintNode(currentNode);
// LeftNeighbors must end before the current node...
int cLeftNeighbours = currentNode.LeftNeighbors.Count;
for (int ii = 0; ii < cLeftNeighbours; ++ii)
{
// Keep track of the original Node; it may be the base of a Cluster, in which
// case it will have the active neighbours list, not leftNeighborNode (which will
// be the left border "fake Node").
OverlapRemovalNode origLeftNeighborNode = currentNode.LeftNeighbors[ii];
origLeftNeighborNode.RightNeighbors.Remove(currentNode);
OverlapRemovalNode leftNeighborNode = GetLeftConstraintNode(origLeftNeighborNode);
Debug.Assert(leftNeighborNode.OpenP == origLeftNeighborNode.OpenP, "leftNeighborNode.OpenP must == origLeftNeighborNode.OpenP");
// This assert verifies we match the Solver.ViolationTolerance check in AddNeighbor.
// We are closing the node here so use an alternative to OverlapP for additional
// consistency verification. Allow a little rounding error.
Debug.Assert(isHorizontal
|| ((currentNode.CloseP + NodePaddingP - leftNeighborNode.OpenP) > (parameters.SolverParameters.GapTolerance - 1e-6)),
"LeftNeighbors: unexpected close/open overlap");
double p = leftNeighborNode == LeftBorderNode || currentRightNode == RightBorderNode ? ClusterPadding : NodePadding;
double separation = ((leftNeighborNode.Size + currentRightNode.Size) / 2) + p;
if (TranslateChildren)
{
separation = Math.Max(separation, currentRightNode.Position - leftNeighborNode.Position);
}
Constraint cst = solver.AddConstraint(leftNeighborNode.Variable, currentRightNode.Variable, separation);
Debug.Assert(null != cst, "LeftNeighbors: unexpected null cst");
#if VERBOSE
Console.WriteLine(" {0} LnbourCst {1} -> {2} g {3:F5}", isHorizontal ? "H" : "V"
, cst.Left.Name, cst.Right.Name, cst.Gap);
#endif // VERBOSE
}
// ... and RightNeighbors must start after the current node.
int cRightNeighbours = currentNode.RightNeighbors.Count;
for (int ii = 0; ii < cRightNeighbours; ++ii)
{
// Keep original node, which may be a cluster; see comments in LeftNeighbors above.
OverlapRemovalNode origRightNeighborNode = currentNode.RightNeighbors[ii];
origRightNeighborNode.LeftNeighbors.Remove(currentNode);
OverlapRemovalNode rightNeighborNode = GetRightConstraintNode(origRightNeighborNode);
// This assert verifies we match the Solver.ViolationTolerance check in AddNeighbor.
// Allow a little rounding error.
Debug.Assert(isHorizontal
|| ((currentNode.CloseP + NodePaddingP - rightNeighborNode.OpenP) > (parameters.SolverParameters.GapTolerance - 1e-6)),
"RightNeighbors: unexpected close/open overlap");
double p = currentLeftNode == LeftBorderNode || rightNeighborNode == RightBorderNode ? ClusterPadding : NodePadding;
double separation = ((currentLeftNode.Size + rightNeighborNode.Size) / 2) + p;
if (TranslateChildren)
{
separation = Math.Max(separation, rightNeighborNode.Position - currentLeftNode.Position);
}
Constraint cst = solver.AddConstraint(currentLeftNode.Variable, rightNeighborNode.Variable, separation);
Debug.Assert(null != cst, "RightNeighbors: unexpected null cst");
#if VERBOSE
Console.WriteLine(" {0} RnbourCst {1} -> {2} g {3:F5}", isHorizontal ? "H" : "V"
, cst.Left.Name, cst.Right.Name, cst.Gap);
#endif // VERBOSE
}
// Note: although currentNode is closed, there may still be open nodes in its
// Neighbour lists; these will subsequently be processed (and removed from
// currentNode.*Neighbour) when those Neighbors are closed.
scanLine.Remove(currentNode);
#if VERBOSE
Console.WriteLine("ScanRem: {0}", currentNode);
#endif // VERBOSE
} // endelse !evt.IsForOpen
// @@PERF: Set Node.Left/RightNeighbors null to let the GC know we're not using them
// anymore, unless we can reasonably assume a short lifetime for the ConstraintGenerator.
} // endforeach Event
}