b381290f34
Pure-Dart P2c slice: interval-aware ports and corridors, label-aware lane spacing, measured label placement with fallback shelf, skipped diagnostics and routing bounds. 20 focused tests plus existing suite and web build pass.
176 lines
4.7 KiB
Dart
176 lines
4.7 KiB
Dart
import 'dart:math' as math;
|
|
|
|
import '../layout/layout_models.dart';
|
|
import 'route_geometry.dart';
|
|
import 'route_models.dart';
|
|
|
|
/// Places one measured edge label without overlapping a node or another label.
|
|
///
|
|
/// Candidates are tried in a deterministic order: the midpoint of each
|
|
/// horizontal run (above, then below), then each vertical run (right, then
|
|
/// left), sliding along the run before giving up. A run too narrow for the
|
|
/// box pushes the label to a free shelf below the drawing, which expands the
|
|
/// routing bounds instead of covering a node.
|
|
EdgeLabelBox placeEdgeLabel({
|
|
required EdgeRoute route,
|
|
required LabelExtent extent,
|
|
required List<GraphNodeBox> nodes,
|
|
required List<EdgeLabelBox> placed,
|
|
required RoutingConfig config,
|
|
required double floorY,
|
|
}) {
|
|
final width = extent.width;
|
|
final height = extent.height;
|
|
for (final candidate in _candidates(route, width, height, config.labelGap)) {
|
|
final box = EdgeLabelBox(
|
|
edgeId: route.id,
|
|
x: candidate.x,
|
|
y: candidate.y,
|
|
width: width,
|
|
height: height,
|
|
);
|
|
if (_fits(box, nodes, placed, config)) return box;
|
|
}
|
|
|
|
// The fallback shelf is below every route and every existing label, so it
|
|
// cannot cover a node. Growing it down expands the returned bounds.
|
|
var top = math.max(
|
|
floorY,
|
|
placed.fold<double>(0, (bottom, box) => math.max(bottom, box.bottom)),
|
|
);
|
|
top += config.labelGap;
|
|
final centre = _routeCentreX(route);
|
|
final step = math.max(height + config.labelGap, 1.0);
|
|
for (var attempt = 0; attempt < 100000; attempt += 1) {
|
|
final x = math.max(0.0, centre - width / 2);
|
|
final box = EdgeLabelBox(
|
|
edgeId: route.id,
|
|
x: x,
|
|
y: top,
|
|
width: width,
|
|
height: height,
|
|
);
|
|
if (_fits(box, nodes, placed, config)) return box;
|
|
top += step;
|
|
}
|
|
// A zero-sized label cannot collide; this is unreachable for real extents.
|
|
return EdgeLabelBox(
|
|
edgeId: route.id,
|
|
x: math.max(0.0, centre - width / 2),
|
|
y: top,
|
|
width: width,
|
|
height: height,
|
|
);
|
|
}
|
|
|
|
bool _fits(
|
|
EdgeLabelBox box,
|
|
List<GraphNodeBox> nodes,
|
|
List<EdgeLabelBox> placed,
|
|
RoutingConfig config,
|
|
) {
|
|
if (box.x < 0 || box.y < 0) return false;
|
|
for (final node in nodes) {
|
|
if (boxIntersectsNode(
|
|
x: box.x,
|
|
y: box.y,
|
|
width: box.width,
|
|
height: box.height,
|
|
node: node,
|
|
gap: config.labelGap,
|
|
)) {
|
|
return false;
|
|
}
|
|
}
|
|
for (final other in placed) {
|
|
if (boxesOverlap(
|
|
ax: box.x,
|
|
ay: box.y,
|
|
aw: box.width,
|
|
ah: box.height,
|
|
bx: other.x,
|
|
by: other.y,
|
|
bw: other.width,
|
|
bh: other.height,
|
|
gap: config.labelGap,
|
|
)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
List<_LabelCandidate> _candidates(
|
|
EdgeRoute route,
|
|
double width,
|
|
double height,
|
|
double gap,
|
|
) {
|
|
const fractions = <double>[0.5, 0.35, 0.65, 0.2, 0.8, 0.08, 0.92];
|
|
final horizontals = <_Run>[];
|
|
final verticals = <_Run>[];
|
|
for (var index = 1; index < route.points.length; index += 1) {
|
|
final a = route.points[index - 1];
|
|
final b = route.points[index];
|
|
if (a.y == b.y) {
|
|
horizontals.add(_Run(a, b, (b.x - a.x).abs(), index));
|
|
} else if (a.x == b.x) {
|
|
verticals.add(_Run(a, b, (b.y - a.y).abs(), index));
|
|
}
|
|
}
|
|
horizontals.sort((a, b) {
|
|
final length = b.length.compareTo(a.length);
|
|
return length != 0 ? length : a.order.compareTo(b.order);
|
|
});
|
|
verticals.sort((a, b) {
|
|
final length = b.length.compareTo(a.length);
|
|
return length != 0 ? length : a.order.compareTo(b.order);
|
|
});
|
|
|
|
final candidates = <_LabelCandidate>[];
|
|
for (final run in horizontals) {
|
|
for (final fraction in fractions) {
|
|
final x = run.a.x + (run.b.x - run.a.x) * fraction;
|
|
final left = x - width / 2;
|
|
candidates.add(_LabelCandidate(left, run.a.y - gap - height));
|
|
candidates.add(_LabelCandidate(left, run.a.y + gap));
|
|
}
|
|
}
|
|
for (final run in verticals) {
|
|
for (final fraction in fractions) {
|
|
final y = run.a.y + (run.b.y - run.a.y) * fraction;
|
|
final top = y - height / 2;
|
|
candidates.add(_LabelCandidate(run.a.x + gap, top));
|
|
candidates.add(_LabelCandidate(run.a.x - gap - width, top));
|
|
}
|
|
}
|
|
return candidates;
|
|
}
|
|
|
|
double _routeCentreX(EdgeRoute route) {
|
|
if (route.points.isEmpty) return 0;
|
|
var lo = route.points.first.x;
|
|
var hi = lo;
|
|
for (final point in route.points) {
|
|
lo = math.min(lo, point.x);
|
|
hi = math.max(hi, point.x);
|
|
}
|
|
return (lo + hi) / 2;
|
|
}
|
|
|
|
class _Run {
|
|
const _Run(this.a, this.b, this.length, this.order);
|
|
|
|
final RoutePoint a;
|
|
final RoutePoint b;
|
|
final double length;
|
|
final int order;
|
|
}
|
|
|
|
class _LabelCandidate {
|
|
const _LabelCandidate(this.x, this.y);
|
|
|
|
final double x;
|
|
final double y;
|
|
}
|