EdgeRouterData<TNode, TEdge, TNodeLabel, TEdgeLabel>

// Try harder to prevent crossings with label1
layoutData.edgeLabelCrossingCostFactors.mapper.set(label1, 1.5)
// Crossings with label2 are not as bad
layoutData.edgeLabelCrossingCostFactors.mapper.set(label2, 0.2)

// The more upper-case letters a label has, the more important it must be
// and crossings should be avoided based on that metric
// todo
layoutData.edgeLabelCrossingCostFactors = (label: ILabel): number =>
  label.text.match(/[A-Z]/g)!.length

layoutData.edgeLabelPreferredPlacements = new EdgeLabelPreferredPlacement(
  {
    // Place labels along the edge
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: 0,
    // ... on either side
    edgeSide: LabelEdgeSides.LEFT_OF_EDGE | LabelEdgeSides.RIGHT_OF_EDGE,
    // ... with a bit of distance to the edge
    distanceToEdge: 5,
  },
)

// Place label1 orthogonal to the edge anywhere on it
layoutData.edgeLabelPreferredPlacements.mapper.set(
  label1,
  new EdgeLabelPreferredPlacement({
    placementAlongEdge: LabelAlongEdgePlacements.ANYWHERE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: Math.PI / 2,
  }),
)
// Place label2 near the edge's source on either side of it, and make it parallel to the edge
layoutData.edgeLabelPreferredPlacements.mapper.set(
  label2,
  new EdgeLabelPreferredPlacement({
    placementAlongEdge: LabelAlongEdgePlacements.AT_SOURCE,
    edgeSide: LabelEdgeSides.RIGHT_OF_EDGE | LabelEdgeSides.LEFT_OF_EDGE,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    angle: 0,
  }),
)

layoutData.edgeLabelPreferredPlacements = (
  label: ILabel,
): EdgeLabelPreferredPlacement => {
  const customData = label.tag as CustomData
  return new EdgeLabelPreferredPlacement({
    angle: 0,
    angleReference: LabelAngleReferences.RELATIVE_TO_EDGE_FLOW,
    // If the tag says to place the label in the center, put it in the center parallel to the edge's path
    // All other labels can be placed anywhere, but on the side of the edge.
    placementAlongEdge: customData.placeInCenter
      ? LabelAlongEdgePlacements.AT_CENTER
      : LabelAlongEdgePlacements.ANYWHERE,
    edgeSide: customData.placeInCenter
      ? LabelEdgeSides.ON_EDGE
      : LabelEdgeSides.LEFT_OF_EDGE | LabelEdgeSides.RIGHT_OF_EDGE,
  })
}

layoutData.edgeLabelPreferredPlacements =
  EdgeLabelPreferredPlacement.fromParameter(
    NinePositionsEdgeLabelModel.CENTER_CENTERED,
  )

// Try harder to prevent crossings with label1
layoutData.nodeLabelCrossingCostFactors.mapper.set(label1, 1.5)
// Crossings with label2 are not as bad
layoutData.nodeLabelCrossingCostFactors.mapper.set(label2, 0.2)

// The more upper-case letters a label has, the more important it must be
// and crossings should be avoided based on that metric
layoutData.nodeLabelCrossingCostFactors = (label: ILabel): number =>
  label.text.match(/[A-Z]/g)!.length

layoutData.nodeMargins = new Insets(20)

// node1 only reserves space above and below
layoutData.nodeMargins.mapper.set(node1, new Insets(20, 10, 0, 0))
// node2 has space all around
layoutData.nodeMargins.mapper.set(node2, new Insets(25))
// all other nodes don't get extra space

// Retrieve the space around the node from its tag property
layoutData.nodeMargins = (node: INode): Insets =>
  new Insets(parseFloat(node.tag))

layoutData.scope.edges.items.add(edge1)
layoutData.scope.edges.items.add(edge2)

// We assume here that all edges have a CustomData instance as their tag,
// which then has a boolean property 'IncludeInLayout'.
layoutData.scope.edges = (edge: IEdge): boolean =>
  (edge.tag as CustomData).includeInLayout

// We assume here that all nodes have a CustomData instance as their tag,
// which then has a boolean property 'IncludeInLayout'.
layoutData.scope.incidentNodes = (node: INode): boolean =>
  (node.tag as CustomData).includeInLayout

layoutData.scope.edgeMapping = (edge) => {
  if (edge == edge1) {
    //edge1 is always routed
    return EdgeRouterScope.PATH
  }
  if (edge == edge2) {
    //edge2 is only routed if necessary
    return EdgeRouterScope.PATH_AS_NEEDED
  }
  if (edge == edge3) {
    //only segments of edge3 are routed if necessary
    return EdgeRouterScope.SEGMENTS_AS_NEEDED
  }
  //other edges are not affected
  return EdgeRouterScope.IGNORE
}

layoutData.sourceGroupIds = (edge: IEdge) => edge.sourceNode

layoutData.sourceGroupIds = (edge: IEdge) => {
  const style = edge.style
  if (style instanceof PolylineEdgeStyle) {
    return style.stroke!.fill
  }
  return null
}

for (const group of edgeGroups) {
  for (const edge of group) {
    // Use the collection as group ID, since it's common to all edges in it
    layoutData.sourceGroupIds.mapper.set(edge, group)
  }
}