Function segmentToDistributedPoints

esm/utils/paths.js:1103–1187

(segment, totalPoints)

} // plots a number of points along the segment as evenly as possible while retaining non-smooth (angled) anchors.

export function segmentToDistributedPoints(segment, totalPoints) {
  segment.samples || measureSegment(segment);
  var samples = segment.samples,
      lookup = segment.lookup,
      resolution = segment.resolution,
      totalLength = segment.totalLength,
      points = segment.slice(0, 2),
      curveStoppingPoints = [],
      l = segment.length - 4,
      i = 6,
      limit = 0.2,
      startLength = 0,
      curvePointsCumulative = 0,
      t,
      curvePoints,
      min,
      max,
      ci,
      ratioInc,
      j,
      inv,
      curveLength,
      length,
      a,
      nonSmooth,
      curveStoppingPointIndex,
      sampleIndex; // first, loop through each anchor and find out if it's smooth (curve) or not by comparing the angle to each control point (if they're within a certain range, it's smooth). We want to keep pivot points (non-smooth) anchors but allow curved/smooth ones to be subject to simplification.

  for (; i < l; i += 6) {
    if (Math.abs(_atan2(segment[i + 1] - segment[i - 1], segment[i] - segment[i - 2]) - _atan2(segment[i + 3] - segment[i + 1], segment[i + 2] - segment[i])) > limit) {
      curveStoppingPoints.push(i);
    }
  }

  curveStoppingPoints.push(segment.length - 2); // the last anchor is always a curve stopping point.

  l = curveStoppingPoints.length;
  points.nonSmooth = nonSmooth = [1]; // keep track of which points are non-smooth so that when we call pointsToSegment() we can maintain their angle.

  if (totalPoints > l) {
    totalPoints -= l;

    for (ci = 0; ci < l; ci++) {
      curveStoppingPointIndex = curveStoppingPoints[ci];
      sampleIndex = Math.round(curveStoppingPointIndex / 6 * resolution);
      curveLength = samples[sampleIndex - 1] - startLength;
      curvePoints = Math.round(samples[sampleIndex - 1] / totalLength * totalPoints) - curvePointsCumulative;
      curvePointsCumulative += curvePoints;
      ratioInc = 1 / (curvePoints + 1);

      for (j = 1; j <= curvePoints; j++) {
        length = startLength + curveLength * j * ratioInc;
        i = lookup.length ? lookup[length < totalLength ? ~~(length / segment.minLength) : lookup.length - 1] || 0 : _getSampleIndex(samples, length, length / totalLength);
        min = i ? samples[i - 1] : 0;
        max = samples[i];

        if (max < length) {
          min = max;