@statelyai/layout 0.3.0 → 0.4.1

package/src/layered/constraint-orientation.ts

@@ -0,0 +1,141 @@
+/*******************************************************************************
+ * Derived from ELK v0.11.0 EdgeAndLayerConstraintEdgeReverser.java.
+ * Copyright (c) 2010, 2017 Kiel University and others.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import { createGraph } from "@statelyai/graph";
+import type { GraphEdge } from "@statelyai/graph";
+import type { AcyclicOrientation, CycleBreaker, LayeredPhaseInput } from "./types";
+import { inheritCycleRandom } from "./cycle-random";
+
+/** ELK handles outer constraints and whole feedback nodes before cycle breaking. */
+export function orientConstrainedEdges(
+  input: LayeredPhaseInput,
+  initial: ReadonlySet<string>,
+): AcyclicOrientation & { reversedNodeIds: readonly string[] } {
+  const reversedEdgeIds = new Set(initial);
+  const reversedNodeIds: string[] = [];
+  const constraints = new Map(
+    input.graph.nodes.map((n) => [n.id, input.nodeSettings?.(n)?.["layering.layerConstraint"]]),
+  );
+  const forward =
+    input.direction === "right"
+      ? "EAST"
+      : input.direction === "left"
+        ? "WEST"
+        : input.direction === "down"
+          ? "SOUTH"
+          : "NORTH";
+  const backward =
+    input.direction === "right"
+      ? "WEST"
+      : input.direction === "left"
+        ? "EAST"
+        : input.direction === "down"
+          ? "NORTH"
+          : "SOUTH";
+  const reverse = (nodeId: string, kind: "incoming" | "outgoing" | "all") => {
+    for (const edge of input.graph.edges) {
+      if (reversedEdgeIds.has(edge.id)) continue;
+      if (
+        edge.sourceId === nodeId &&
+        kind !== "incoming" &&
+        constraints.get(edge.targetId) !== "LAST_SEPARATE"
+      )
+        reversedEdgeIds.add(edge.id);
+      else if (
+        edge.targetId === nodeId &&
+        kind !== "outgoing" &&
+        constraints.get(edge.sourceId) !== "FIRST_SEPARATE"
+      )
+        reversedEdgeIds.add(edge.id);
+    }
+  };
+  for (const node of input.graph.nodes) {
+    const c = constraints.get(node.id);
+    if (c === "FIRST" || c === "FIRST_SEPARATE") reverse(node.id, "incoming");
+    else if (c === "LAST" || c === "LAST_SEPARATE") reverse(node.id, "outgoing");
+  }
+  for (const node of input.graph.nodes) {
+    if (constraints.get(node.id) && constraints.get(node.id) !== "NONE") continue;
+    const fixed = input.nodeSettings?.(node)?.portConstraints;
+    if (
+      !["FIXED_SIDE", "FIXED_ORDER", "FIXED_RATIO", "FIXED_POS"].includes(String(fixed)) ||
+      !node.ports?.length
+    )
+      continue;
+    const ports = new Map(
+      node.ports.map((p) => [
+        p.name,
+        { side: input.portSettings?.(p, node)?.["port.side"], net: 0 },
+      ]),
+    );
+    let protectedNeighbor = false;
+    for (const edge of input.graph.edges) {
+      const reversed = reversedEdgeIds.has(edge.id);
+      const source = reversed ? edge.targetId : edge.sourceId;
+      const target = reversed ? edge.sourceId : edge.targetId;
+      for (const incoming of [false, true]) {
+        if ((incoming ? target : source) !== node.id) continue;
+        const name = incoming
+          ? reversed
+            ? edge.sourcePort
+            : edge.targetPort
+          : reversed
+            ? edge.targetPort
+            : edge.sourcePort;
+        const key = name ?? `__implicit:${edge.id}:${incoming}`;
+        const port = ports.get(key) ?? { side: incoming ? backward : forward, net: 0 };
+        port.net += incoming ? 1 : -1;
+        ports.set(key, port);
+        const otherConstraint = constraints.get(incoming ? source : target);
+        if (
+          incoming
+            ? otherConstraint === "FIRST" || otherConstraint === "FIRST_SEPARATE"
+            : otherConstraint === "LAST" || otherConstraint === "LAST_SEPARATE"
+        )
+          protectedNeighbor = true;
+      }
+    }
+    // Fixed-side UNDEFINED ports are assigned the side opposite their flow.
+    // An unused or non-flow port prevents whole-node feedback reversal.
+    const allReversed = [...ports.values()].every((p) => {
+      const side = p.side === "UNDEFINED" ? (p.net > 0 ? forward : backward) : p.side;
+      return (side === forward && p.net > 0) || (side === backward && p.net < 0);
+    });
+    if (allReversed && !protectedNeighbor) {
+      reversedNodeIds.push(node.id);
+      reverse(node.id, "all");
+    }
+  }
+  return { reversedEdgeIds, reversedNodeIds };
+}
+
+/** Preserve original edge identities and carry the actual post-cycle RNG back. */
+export function breakCyclesWithConstraints(
+  input: LayeredPhaseInput,
+  breaker: CycleBreaker,
+): AcyclicOrientation {
+  const prepared = orientConstrainedEdges(input, new Set()).reversedEdgeIds;
+  if (!prepared.size) return breaker(input);
+  const edges: GraphEdge[] = input.graph.edges.map((e) =>
+    prepared.has(e.id)
+      ? {
+          ...e,
+          sourceId: e.targetId,
+          targetId: e.sourceId,
+          sourcePort: e.targetPort,
+          targetPort: e.sourcePort,
+        }
+      : e,
+  );
+  const phaseInput: LayeredPhaseInput = { ...input, graph: createGraph({ ...input.graph, edges }) };
+  const cycles = breaker(phaseInput);
+  inheritCycleRandom(phaseInput, input);
+  const reversedEdgeIds = new Set(prepared);
+  for (const id of cycles.reversedEdgeIds) {
+    if (reversedEdgeIds.has(id)) reversedEdgeIds.delete(id);
+    else reversedEdgeIds.add(id);
+  }
+  return { reversedEdgeIds };
+}

package/src/layered/crossing-constraints.ts

@@ -0,0 +1,243 @@
+/*******************************************************************************
+ * Copyright (c) 2016, 2020 Kiel University and others.
+ * Adapted from ELK v0.11.0 ForsterConstraintResolver and BarycenterHeuristic.
+ * Source commit: 54123e884b1ae743b453260f713b20c9bf5787f2
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+import type { JavaRandom } from "../java-random";
+import type { LayeredPhaseInput } from "./types";
+export interface CrossingUnits {
+  /** Edge positions in ELK's port edge lists at crossing minimization. */
+  edgeListRanks?: {
+    incoming: ReadonlyMap<string, ReadonlyMap<string, number>>;
+    outgoing: ReadonlyMap<string, ReadonlyMap<string, number>>;
+  };
+  northSouthOrigins?: ReadonlyMap<string, import("./north-south-ports").CrossPortOrigin>;
+  successors: ReadonlyMap<string, readonly string[]>;
+  units: ReadonlyMap<string, string>;
+  unitMembers?: ReadonlyMap<string, readonly string[]>;
+  associates: ReadonlyMap<string, readonly string[]>;
+  normalNodes: ReadonlySet<string>;
+  incomingEdgeOrderByDummyId?: ReadonlyMap<string, readonly string[]>;
+  longEdgeNodes?: ReadonlySet<string>;
+  northEdges?: ReadonlySet<string>;
+  southEdges?: ReadonlySet<string>;
+  constraintsBetweenNormalNodes?: boolean;
+}
+const unitState = new WeakMap<LayeredPhaseInput, CrossingUnits>();
+export const recordCrossingUnits = (input: LayeredPhaseInput, state: CrossingUnits): void => {
+  unitState.set(input, state);
+};
+export const getCrossingUnits = (input: LayeredPhaseInput): CrossingUnits | undefined =>
+  unitState.get(input);
+
+/** Recursively include same-layer neighbors and owner associates before perturbation. */
+export function associatedBarycenters(
+  layer: readonly string[],
+  ranks: ReadonlyMap<string, readonly number[]>,
+  sameLayerNeighbors: ReadonlyMap<string, readonly string[]>,
+  associates: ReadonlyMap<string, readonly string[]>,
+  random?: JavaRandom,
+  orderedVisits?: ReadonlyMap<string, readonly (number | string)[]>,
+): Map<string, number | undefined> {
+  const states = new Map(
+    layer.map((id) => [
+      id,
+      { visited: false, degree: 0, weight: 0, barycenter: undefined as number | undefined },
+    ]),
+  );
+  const calculate = (id: string): void => {
+    const state = states.get(id);
+    if (!state || state.visited) return;
+    state.visited = true;
+    const includeNeighbor = (neighbor: string): void => {
+      calculate(neighbor);
+      const other = states.get(neighbor);
+      if (other) {
+        state.degree += other.degree;
+        state.weight += other.weight;
+      }
+    };
+    // ELK walks ports, then their incident edges. Same-layer recursion must
+    // occur at that exact position, before any later fixed-layer rank.
+    const visits = orderedVisits?.get(id) ?? [
+      ...(ranks.get(id) ?? []),
+      ...(sameLayerNeighbors.get(id) ?? []),
+    ];
+    for (const visit of visits) {
+      if (typeof visit === "number") {
+        state.degree++;
+        state.weight += visit;
+      } else if (visit !== id) includeNeighbor(visit);
+    }
+    for (const associate of associates.get(id) ?? []) includeNeighbor(associate);
+    if (state.degree > 0) {
+      state.weight += random ? random.nextFloat() * Math.fround(0.07) - Math.fround(0.07) / 2 : 0;
+      state.barycenter = state.weight / state.degree;
+    }
+  };
+  for (const id of layer) calculate(id);
+  return new Map([...states].map(([id, s]) => [id, s.barycenter]));
+}
+
+interface Group {
+  nodes: string[];
+  outgoing: Group[];
+  incoming: Group[];
+  incomingCount: number;
+}
+/** Resolve successor and layout-unit constraints by merging violated groups in barycenter order. */
+export function resolveCrossingConstraints(
+  order: readonly string[],
+  barycenters: Map<string, number | undefined>,
+  state: CrossingUnits,
+): string[] {
+  if (state.constraintsBetweenNormalNodes) {
+    const normalOnly = new Map(
+      [...state.successors]
+        .filter(([id]) => state.normalNodes.has(id))
+        .map(([id, targets]) => [id, targets.filter((target) => state.normalNodes.has(target))]),
+    );
+    const first = resolveCrossingConstraints(order, barycenters, {
+      ...state,
+      successors: normalOnly,
+      units: new Map(),
+      unitMembers: new Map(),
+      constraintsBetweenNormalNodes: false,
+    });
+    return resolveCrossingConstraints(first, barycenters, {
+      ...state,
+      constraintsBetweenNormalNodes: false,
+    });
+  }
+  const groups: Group[] = order.map((id) => ({
+    nodes: [id],
+    outgoing: [],
+    incoming: [],
+    incomingCount: 0,
+  }));
+  const byId = new Map(groups.map((g) => [g.nodes[0]!, g]));
+  const score = (g: Group) => barycenters.get(g.nodes[0]!) ?? 0;
+  const units = new Map<string, string[]>();
+  if (state.unitMembers)
+    for (const [owner, members] of state.unitMembers)
+      units.set(
+        owner,
+        members.filter((id) => byId.has(id)),
+      );
+  else
+    for (const [id, owner] of state.units)
+      if (byId.has(id)) units.set(owner, [...(units.get(owner) ?? []), id]);
+  const add = (from: Group, to: Group) => {
+    from.outgoing.push(to);
+    to.incomingCount++;
+  };
+  let previous: string | undefined;
+  for (const id of order) {
+    const group = byId.get(id)!;
+    for (const successor of state.successors.get(id) ?? []) {
+      const target = byId.get(successor);
+      if (target) add(group, target);
+    }
+    if (state.normalNodes.has(id)) {
+      if (previous !== undefined)
+        for (const left of units.get(previous) ?? [])
+          for (const right of units.get(id) ?? []) add(byId.get(left)!, byId.get(right)!);
+      previous = id;
+    }
+  }
+  const violation = (): [Group, Group] | undefined => {
+    const active: Group[] = [];
+    for (const g of groups) {
+      g.incoming = [];
+      if (g.outgoing.length && g.incomingCount === 0) active.push(g);
+    }
+    for (let index = 0; index < active.length; index++) {
+      const group = active[index]!;
+      for (const predecessor of group.incoming) {
+        // elkjs Double.floatValue is an identity conversion, not float32 rounding.
+        if (
+          score(predecessor) === score(group)
+            ? groups.indexOf(predecessor) > groups.indexOf(group)
+            : score(predecessor) > score(group)
+        )
+          return [predecessor, group];
+      }
+      for (const target of group.outgoing) {
+        target.incoming.unshift(group);
+        if (target.incoming.length === target.incomingCount) active.push(target);
+      }
+    }
+    return undefined;
+  };
+  const removeOne = (values: Group[], target: Group): boolean => {
+    const index = values.indexOf(target);
+    if (index < 0) return false;
+    values.splice(index, 1);
+    return true;
+  };
+  let pair: [Group, Group] | undefined;
+  while ((pair = violation())) {
+    const [first, second] = pair;
+    // ConstraintGroup degrees/weights start at zero in ELK: merged scores use
+    // the mean of two group scores, not their node or edge counts.
+    const value = (score(first) + score(second)) / 2;
+    const merged: Group = {
+      nodes: [...first.nodes, ...second.nodes],
+      outgoing: [...first.outgoing],
+      incoming: [],
+      incomingCount: 0,
+    };
+    removeOne(merged.outgoing, second);
+    for (const target of second.outgoing)
+      if (target !== first) {
+        if (merged.outgoing.includes(target)) target.incomingCount--;
+        else merged.outgoing.push(target);
+      }
+    for (const id of merged.nodes) barycenters.set(id, value);
+    const survivors: Group[] = [];
+    let inserted = false;
+    for (const group of groups) {
+      if (group === first || group === second) continue;
+      if (!inserted && score(group) > value) {
+        survivors.push(merged);
+        inserted = true;
+      }
+      if (group.outgoing.length) {
+        const hadFirst = removeOne(group.outgoing, first),
+          hadSecond = removeOne(group.outgoing, second);
+        if (hadFirst || hadSecond) {
+          group.outgoing.push(merged);
+          merged.incomingCount++;
+        }
+      }
+      survivors.push(group);
+    }
+    if (!inserted) survivors.push(merged);
+    groups.splice(0, groups.length, ...survivors);
+  }
+  return groups.flatMap((g) => g.nodes);
+}
+
+/** ELK greedy switches must preserve port-unit and explicit successor constraints. */
+export function canSwapCrossingUnits(upper: string, lower: string, state: CrossingUnits): boolean {
+  if (state.successors.get(upper)?.includes(lower)) return false;
+  const up = state.units.get(upper),
+    down = state.units.get(lower);
+  const upperDummy = up !== undefined && up !== upper,
+    lowerDummy = down !== undefined && down !== lower;
+  const different = up !== down;
+  const constrained =
+    upperDummy || lowerDummy || state.southEdges?.has(upper) || state.northEdges?.has(lower);
+  if (state.northEdges?.has(upper) || state.southEdges?.has(lower)) return false;
+  if (
+    !state.longEdgeNodes?.has(upper) &&
+    !state.longEdgeNodes?.has(lower) &&
+    constrained &&
+    different
+  )
+    return false;
+  if ((upperDummy && state.normalNodes.has(lower)) || (lowerDummy && state.normalNodes.has(upper)))
+    return false;
+  return true;
+}

package/src/layered/crossing-counter.ts

@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2016, 2020 Kiel University and others.
+ * Native adaptation of ELK AllCrossingsCounter and CrossingsCounter.
+ * SPDX-License-Identifier: EPL-2.0
+ */
+import { scoreOrthogonalHypersegments } from "./orthogonal-hypersegments";
+
+export interface CrossingPort {
+  id: string;
+  side: "NORTH" | "EAST" | "SOUTH" | "WEST";
+  /** Normal cross-axis port's detached dummy. */
+  dummy?: string;
+  /** Detached cross-axis dummy port's original normal port. */
+  origin?: string;
+}
+export interface CrossingNode {
+  id: string;
+  type: "NORMAL" | "LONG_EDGE" | "NORTH_SOUTH_PORT" | "LABEL" | "EXTERNAL_PORT";
+  /** Clockwise canonical port order. */
+  ports: CrossingPort[];
+  unit?: string;
+}
+export interface CrossingGraph {
+  layers: CrossingNode[][];
+  edges: Array<{ source: string; target: string }>;
+}
+export interface CrossingScore {
+  betweenLayers: number;
+  inLayer: number;
+  northSouth: number;
+  total: number;
+  /** Some hyperedge joins two or more ports on each side of its gap. */
+  sharedTracks: boolean;
+}
+
+class IndexTree {
+  private readonly sums: number[];
+  private readonly entries: number[];
+  size = 0;
+  constructor(size: number) {
+    this.sums = Array(size + 1).fill(0);
+    this.entries = Array(size).fill(0);
+  }
+  add(position: number): void {
+    this.entries[position]!++;
+    this.size++;
+    for (let i = position + 1; i < this.sums.length; i += i & -i) this.sums[i]!++;
+  }
+  remove(position: number): void {
+    const count = this.entries[position]!;
+    if (!count) return;
+    this.entries[position] = 0;
+    this.size -= count;
+    for (let i = position + 1; i < this.sums.length; i += i & -i) this.sums[i]! -= count;
+  }
+  rank(position: number): number {
+    let value = 0;
+    for (let i = position; i > 0; i -= i & -i) value += this.sums[i]!;
+    return value;
+  }
+}
+
+/** Score a canonical candidate without changing its node or port orders. */
+export function countAllCrossings(
+  graph: CrossingGraph,
+  /** "separated" counts hyperedges like ELK unless they would share a track (see scoreOrthogonalHypersegments). */
+  boundaryMode: "hyperedges" | "separated" | "edges" = "hyperedges",
+): CrossingScore {
+  const nodes = new Map(graph.layers.flat().map((node) => [node.id, node]));
+  const layerByPort = new Map<string, number>();
+  const incoming = new Map<string, string[]>(),
+    outgoing = new Map<string, string[]>();
+  for (const [layer, members] of graph.layers.entries())
+    for (const node of members)
+      for (const port of node.ports) {
+        layerByPort.set(port.id, layer);
+        incoming.set(port.id, []);
+        outgoing.set(port.id, []);
+      }
+  for (const edge of graph.edges) {
+    outgoing.get(edge.source)!.push(edge.target);
+    incoming.get(edge.target)!.push(edge.source);
+  }
+  const connected = (id: string) => [...incoming.get(id)!, ...outgoing.get(id)!];
+  const degree = (id: string) => incoming.get(id)!.length + outgoing.get(id)!.length;
+  const face = (layer: readonly CrossingNode[], side: "EAST" | "WEST", topDown = true) =>
+    (topDown ? layer : [...layer].reverse()).flatMap((node) => {
+      const ports = node.ports.filter((port) => port.side === side);
+      return (side === "EAST") === topDown ? ports : ports.reverse();
+    });
+  const countPorts = (ports: readonly CrossingPort[], inLayerOnly: boolean): number => {
+    const positions = new Map(ports.map((port, index) => [port.id, index]));
+    const tree = new IndexTree(ports.length);
+    let crossings = 0;
+    for (const [position, port] of ports.entries()) {
+      tree.remove(position);
+      const pending: number[] = [];
+      for (const peer of connected(port.id)) {
+        if (inLayerOnly && layerByPort.get(peer) !== layerByPort.get(port.id)) {
+          crossings += tree.size;
+          continue;
+        }
+        const end = positions.get(peer);
+        if (end !== undefined && end > position) {
+          crossings += tree.rank(end);
+          pending.push(end);
+        }
+      }
+      for (const end of pending) tree.add(end);
+    }
+    return crossings;
+  };
+  const countNorthSouth = (layer: readonly CrossingNode[]): number => {
+    const ports: CrossingPort[] = [],
+      stack: CrossingPort[] = [];
+    const flush = () => {
+      ports.push(...stack);
+      stack.length = 0;
+    };
+    let lastUnit: string | undefined;
+    for (const node of layer) {
+      if (lastUnit && lastUnit !== node.id && node.unit && node.unit !== lastUnit) flush();
+      if (node.unit) lastUnit = node.unit;
+      if (node.type === "NORMAL") {
+        ports.push(...node.ports.filter((port) => port.side === "NORTH" && port.dummy));
+        flush();
+        ports.push(...node.ports.filter((port) => port.side === "SOUTH" && port.dummy));
+      } else if (node.type === "NORTH_SOUTH_PORT" || node.type === "LONG_EDGE") {
+        const west = node.ports.find((port) => port.side === "WEST");
+        const east = node.ports.find((port) => port.side === "EAST");
+        if (west) ports.push(west);
+        if (east) stack.unshift(east);
+      }
+    }
+    flush();
+    const positions = new Map(ports.map((port, index) => [port.id, index]));
+    const ownerByPort = new Map(
+      layer.flatMap((node) => node.ports.map((port) => [port.id, node] as const)),
+    );
+    const tree = new IndexTree(ports.length);
+    let crossings = 0;
+    for (const [position, port] of ports.entries()) {
+      tree.remove(position);
+      const node = ownerByPort.get(port.id)!;
+      const targets =
+        node.type === "NORMAL"
+          ? nodes.get(port.dummy!)!.ports.map((peer) => ({ id: peer.id, degree: degree(peer.id) }))
+          : node.type === "LONG_EDGE"
+            ? node.ports
+                .filter((peer) => peer.id !== port.id)
+                .slice(0, 1)
+                .map((peer) => ({ id: peer.id, degree: degree(peer.id) }))
+            : port.origin
+              ? [{ id: port.origin, degree: degree(port.id) }]
+              : [];
+      const pending: number[] = [];
+      for (const target of targets) {
+        const end = positions.get(target.id);
+        if (end !== undefined && end > position) {
+          crossings += tree.rank(end) * target.degree;
+          pending.push(end);
+        }
+      }
+      for (const end of pending) tree.add(end);
+    }
+    return crossings;
+  };
+  const score: CrossingScore = {
+    betweenLayers: 0,
+    inLayer: 0,
+    northSouth: 0,
+    total: 0,
+    sharedTracks: false,
+  };
+  if (!graph.layers.length) return score;
+  score.inLayer += countPorts(face(graph.layers[0]!, "WEST"), true);
+  score.inLayer += countPorts(face(graph.layers.at(-1)!, "EAST"), true);
+  for (const [index, layer] of graph.layers.entries()) {
+    const next = graph.layers[index + 1];
+    if (next) {
+      const hyper =
+        layer.some((node) =>
+          node.ports.some((port) => port.side === "EAST" && degree(port.id) > 1),
+        ) ||
+        next.some((node) => node.ports.some((port) => port.side === "WEST" && degree(port.id) > 1));
+      if (hyper && boundaryMode !== "edges") {
+        const sourcePorts = layer
+          .flatMap((node) => node.ports)
+          .filter((port) => outgoing.get(port.id)!.some((peer) => layerByPort.get(peer) !== index));
+        const targetPorts = next.flatMap((node) => {
+          const connectedPorts = node.ports.filter((port) =>
+            incoming.get(port.id)!.some((peer) => layerByPort.get(peer) !== index + 1),
+          );
+          return [
+            ...connectedPorts.filter((port) => port.side === "NORTH").reverse(),
+            ...connectedPorts.filter((port) => port.side !== "NORTH").reverse(),
+          ];
+        });
+        const sources = new Set(sourcePorts.map((port) => port.id)),
+          targets = new Set(targetPorts.map((port) => port.id));
+        const hyperedges = scoreOrthogonalHypersegments(
+          [
+            ...sourcePorts.map((port, position) => ({
+              id: port.id,
+              side: "source" as const,
+              position,
+            })),
+            ...targetPorts.map((port, position) => ({
+              id: port.id,
+              side: "target" as const,
+              position,
+            })),
+          ],
+          graph.edges.filter((edge) => sources.has(edge.source) && targets.has(edge.target)),
+          boundaryMode === "separated",
+        );
+        score.betweenLayers += hyperedges.count;
+        score.sharedTracks ||= hyperedges.shared;
+        score.inLayer +=
+          countPorts(face(layer, "EAST"), true) + countPorts(face(next, "WEST"), true);
+      } else {
+        score.betweenLayers += countPorts(
+          [...face(layer, "EAST"), ...face(next, "WEST", false)],
+          false,
+        );
+      }
+    }
+    if (layer.some((node) => node.type === "NORTH_SOUTH_PORT"))
+      score.northSouth += countNorthSouth(layer);
+  }
+  score.total = score.betweenLayers + score.inLayer + score.northSouth;
+  return score;
+}