GenericLabelingData<TNode, TEdge, TNodeLabel, TEdgeLabel>

const centerCandidate = new EdgeLabelCandidates().addDiscreteCandidates(
  DiscreteEdgeLabelPositions.CENTER,
)
layoutData.edgeLabelCandidates = centerCandidate

const topCenter = new OrientedRectangle(100, 0, 50, 20)
layoutData.edgeLabelCandidates = (label) =>
  label.text == 'Title'
    ? new EdgeLabelCandidates().addFixedCandidate(topCenter)
    : new EdgeLabelCandidates().addFreeCandidates()

const candidates = new EdgeLabelCandidates()
//Add primary candidate with high weight
candidates.addSliderCandidates({
  mode: EdgeLabelSliderMode.CENTER,
  weight: 1.0,
})

//Add fallback candidates with lower weight
candidates.addDiscreteCandidates({
  labelPositions: DiscreteEdgeLabelPositions.SIX_POS,
  weight: 0.5,
})

layoutData.edgeLabelCandidates = candidates

graph.applyLayout(new HierarchicalLayout(), layoutData)

graph.labels.forEach((label) => {
  if (label.owner instanceof IEdge) {
    console.log(
      `Candidate ${layoutData.edgeLabelCandidatesResult.get(label)} has been chosen for label ${label}`,
    )
  }
})

layoutData.edgeLabelingCosts = new LabelingCosts(
  LabelingOptimizationStrategy.LABEL_OVERLAPS,
)

// edgeLabel1 avoids overlapping other labels as much as possible
layoutData.edgeLabelingCosts.mapper.set(
  edgeLabel1,
  new LabelingCosts(LabelingOptimizationStrategy.LABEL_OVERLAPS),
)
// edgeLabel2 avoids overlapping edges as much as possible
layoutData.edgeLabelingCosts.mapper.set(
  edgeLabel2,
  new LabelingCosts(LabelingOptimizationStrategy.EDGE_OVERLAPS),
)
// all other edge labels will default to the GenericLabeling.DefaultEdgeLabelingPenalties

// Retrieve the penalties of an edge label from its tag property
layoutData.edgeLabelingCosts = (label) => label.tag as LabelingCosts

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,
  )

layoutData.nodeLabelCandidateProcessors.constant = (
  candidates: IEnumerable<LabelCandidate>,
  _: LayoutNodeLabel,
) => {
  candidates.forEach((labelCandidate) => {
    //avoid label positions that moved below the x-axis, e.g., because the owner was moved by a preceding layout run
    labelCandidate.weight = labelCandidate.layout.anchorY < 0 ? 1.0 : 0.2
  })
}

const weightRatio = 0.8
layoutData.nodeLabelCandidateProcessors.constant = (
  candidates: IEnumerable<LabelCandidate>,
  label: LayoutNodeLabel,
) => {
  candidates.forEach((labelCandidate) => {
    const customWeight = calculateCustomWeight(label, labelCandidate)
    labelCandidate.weight =
      labelCandidate.weight * (1 - weightRatio) +
      customWeight * weightRatio
  })
}

layoutData.nodeLabelCandidateProcessors.mapperFunction = (
  viewLabel: ILabel,
) => {
  return (
    candidates: IEnumerable<LabelCandidate>,
    label: LayoutNodeLabel,
  ) => {
    candidates.forEach((labelCandidate) => {
      const candidateBox = labelCandidate.layout
      if (
        viewLabel.text == 'Horizontal label' &&
        !(candidateBox.upX == 0 && candidateBox.upY == -1)
      ) {
        //non-horizontal candidates are very undesirable for certain labels
        labelCandidate.weight = 0.0
      }
      //else: keep calculated weight
    })
  }
}

const centerCandidate = new NodeLabelCandidates().addDiscreteCandidates(
  DiscreteNodeLabelPositions.CENTER,
)
layoutData.nodeLabelCandidates = centerCandidate

const topCenter = new OrientedRectangle(100, 0, 50, 20)
layoutData.nodeLabelCandidates = (label) =>
  label.text == 'Title'
    ? new NodeLabelCandidates().addFixedCandidate(topCenter)
    : new NodeLabelCandidates().addFreeCandidates()

const candidates = new NodeLabelCandidates()
//add primary candidate with high weight
candidates.addDiscreteCandidates({
  labelPositions: DiscreteNodeLabelPositions.CENTER,
  weight: 1.0,
})

//add fallback candidates with lower weight
candidates.addDiscreteCandidates({
  labelPositions: DiscreteNodeLabelPositions.CORNERS,
  weight: 0.5,
})

layoutData.nodeLabelCandidates = candidates

graph.applyLayout(new HierarchicalLayout(), layoutData)

graph.labels.forEach((label) => {
  if (label.owner instanceof INode) {
    console.log(
      `Candidate ${layoutData.nodeLabelCandidatesResult.get(label)} has been chosen for label ${label}`,
    )
  }
})

layoutData.nodeLabelingCosts = new LabelingCosts(
  LabelingOptimizationStrategy.LABEL_OVERLAPS,
)

// edgeLabel1 avoids overlapping other labels as much as possible
layoutData.nodeLabelingCosts.mapper.set(
  edgeLabel1,
  new LabelingCosts(LabelingOptimizationStrategy.LABEL_OVERLAPS),
)
// edgeLabel2 avoids overlapping edges as much as possible
layoutData.nodeLabelingCosts.mapper.set(
  edgeLabel2,
  new LabelingCosts(LabelingOptimizationStrategy.NODE_OVERLAPS),
)
// all other edge labels will default to the GenericLabeling.DefaultNodeLabelingPenalties

// Retrieve the descriptor of an edge label from its tag property
layoutData.nodeLabelingCosts = (label) => label.tag as LabelingCosts

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))

const affectedEdgeLabels = layoutData.scope.edgeLabels.items
affectedEdgeLabels.add(edgeLabel1)
affectedEdgeLabels.add(edgeLabel2)

// All node labels should be affected unless they're marked as "Fixed"
layoutData.scope.nodeLabels = (label) => label.tag != 'Fixed'

// All labels owned by the selected edges should be affected
layoutData.scope.edges = graphComponent.selection.edges

// The labels of all selected nodes should be affected
layoutData.scope.nodes = graphComponent.selection.nodes
// But only if they are not marked as "Fixed"
layoutData.scope.nodeLabels = (label) => label.tag != 'Fixed'