markType1Conflicts method

Map<int, int> markType1Conflicts(bool downward)

Implementation

Map<int, int> markType1Conflicts(bool downward) {
  if (layers.length >= 4) {
    int upper;
    int lower; // iteration bounds;
    int k1; // node position boundaries of closest inner segments;
    if (downward) {
      lower = 1;
      upper = layers.length - 2;
    } else {
      lower = layers.length - 1;
      upper = 2;
    }
    /*;
           * iterate level[2..h-2] in the given direction;
           * available 1 levels to h;
           */
    for (var i = lower; downward ? i <= upper : i >= upper; i += downward ? 1 : -1) {
      var k0 = 0;
      var firstIndex = 0; // index of first node on layer;
      final currentLevel = layers[i];
      final nextLevel = downward ? layers[i + 1] : layers[i - 1];

      // for all nodes on next level;
      for (var l1 = 0; l1 < nextLevel.length; l1++) {
        final virtualTwin = virtualTwinNode(nextLevel[l1], downward);

        if (l1 == nextLevel.length - 1 || virtualTwin != null) {
          k1 = currentLevel.length - 1;

          if (virtualTwin != null) {
            k1 = positionOfNode(virtualTwin);
          }

          while (firstIndex <= l1) {
            final upperNeighbours = getAdjNodes(nextLevel[l1], downward);

            for (var currentNeighbour in upperNeighbours) {
              /*;
              *  XXX< 0 in first iteration is still ok for indizes starting;
              * with 0 because no index can be smaller than 0;
               */
              final currentNeighbourIndex = positionOfNode(currentNeighbour);

              if (currentNeighbourIndex < k0 || currentNeighbourIndex > k1) {
                type1Conflicts[l1] = currentNeighbourIndex;
              }
            }
            firstIndex++;
          }

          k0 = k1;
        }
      }
    }
  }
  return type1Conflicts;
}