+ for (int[] r : map.toShifts)
+ {
+ toShifts.add(new int[] { r[0], r[1] });
+ }
+ }
+ }
+
+ /**
+ * Constructor given ranges as lists of [start, end] positions. There is no
+ * validation check that the ranges do not overlap each other.
+ *
+ * @param fromRange
+ * @param toRange
+ * @param fromRatio
+ * @param toRatio
+ */
+ public MapList(List<int[]> fromRange, List<int[]> toRange, int fromRatio,
+ int toRatio)
+ {
+ this();
+ fromRange = coalesceRanges(fromRange);
+ toRange = coalesceRanges(toRange);
+ this.fromShifts = fromRange;
+ this.toShifts = toRange;
+ this.fromRatio = fromRatio;
+ this.toRatio = toRatio;
+
+ fromLowest = Integer.MAX_VALUE;
+ fromHighest = Integer.MIN_VALUE;
+ for (int[] range : fromRange)
+ {
+ fromLowest = Math.min(fromLowest, Math.min(range[0], range[1]));
+ fromHighest = Math.max(fromHighest, Math.max(range[0], range[1]));
+ }
+
+ toLowest = Integer.MAX_VALUE;
+ toHighest = Integer.MIN_VALUE;
+ for (int[] range : toRange)
+ {
+ toLowest = Math.min(toLowest, Math.min(range[0], range[1]));
+ toHighest = Math.max(toHighest, Math.max(range[0], range[1]));
+ }
+ }
+
+ /**
+ * Consolidates a list of ranges so that any contiguous ranges are merged
+ *
+ * @param ranges
+ * @return
+ */
+ public static List<int[]> coalesceRanges(List<int[]> ranges)
+ {
+ if (ranges == null || ranges.size() < 2) {
+ return ranges;
+ }
+
+ boolean changed = false;
+ List<int[]> merged = new ArrayList<int[]>();
+ int[] lastRange = ranges.get(0);
+ int lastDirection = lastRange[1] >= lastRange[0] ? 1 : -1;
+ merged.add(lastRange);
+
+ for (int[] range : ranges)
+ {
+ if (range == lastRange)
+ {
+ continue;
+ }
+ int direction = range[1] >= range[0] ? 1 : -1;
+
+ /*
+ * if next range is in the same direction as last and contiguous,
+ * just update the end position of the last range
+ */
+ if ((range[1] == range[0] || direction == lastDirection)
+ && (range[0] == lastRange[1] || range[0] == lastRange[1]
+ + lastDirection))
+ {
+ lastRange[1] = range[1];
+ changed = true;
+ }
+ else