Port line-dasharray fix from gl-js

* Fix artifact for zero-lenghted dash array
Fixes issue mapbox/mapbox-gl-js#9213 and add
render test for coverage around 0-length dash arrays

Update distance field generation for regular dashes as follows:
1. Compute the dash array ranges and stretch location along the distance field
2. Collapse any 0-length distance field range
3. Collapse neighbouring same-type parts into single part

* combine consecutive dashes and parts

mapbox/mapbox-gl-js#9246
#16181

src/mbgl/geometry/line_atlas.cpp

@@ -20,12 +20,112 @@ size_t getDashPatternHash(const std::vector<float>& dasharray, const LinePattern
  return key;
 }
 
+std::vector<DashRange> getDashRanges(const std::vector<float>& dasharray, float stretch) {
+ // If dasharray has an odd length, both the first and last parts
+ // are dashes and should be joined seamlessly.
+ const bool oddDashArray = dasharray.size() % 2 == 1;
+
+ float left = oddDashArray ? -dasharray.back() * stretch : 0.0f;
+ float right = dasharray.front() * stretch;
+ bool isDash = true;
+
+ std::vector<DashRange> ranges;
+ ranges.push_back({left, right, isDash, dasharray.front() == 0.0f});
+
+ float currentDashLength = dasharray.front();
+ for (size_t i = 1; i < dasharray.size(); ++i) {
+ isDash = !isDash;
+
+ const float dashLength = dasharray[i];
+ left = currentDashLength * stretch;
+ currentDashLength += dashLength;
+ right = currentDashLength * stretch;
+
+ ranges.push_back({left, right, isDash, dashLength == 0.0f});
+ }
+
+ return ranges;
+}
+
+void addRoundDash(const std::vector<DashRange>& ranges, const int32_t yOffset, float stretch, const int n, AlphaImage& image) {
+ const float halfStretch = stretch * 0.5f;
+
+ for (int y = -n; y <= n; y++) {
+ int row = yOffset + n + y;
+ int index = image.size.width * row;
+ int currIndex = 0;
+ DashRange range = ranges[currIndex];
+
+ for (uint32_t x = 0; x < image.size.width; x++) {
+ if (x / range.right > 1.0f) { range = ranges[++currIndex]; }
+
+ float distLeft = fabsf(x - range.left);
+ float distRight = fabsf(x - range.right);
+ float minDist = fminf(distLeft, distRight);
+ float signedDistance;
+
+ float distMiddle = static_cast<float>(y) / n * (halfStretch + 1.0f);
+ if (range.isDash) {
+ float distEdge = halfStretch - fabsf(distMiddle);
+ signedDistance = sqrtf(minDist * minDist + distEdge * distEdge);
+ } else {
+ signedDistance = halfStretch - sqrtf(minDist * minDist + distMiddle * distMiddle);
+ }
+
+ image.data[index + x] = static_cast<uint8_t>(fmaxf(0.0f, fminf(255.0f, signedDistance + 128.0f)));
+ }
+ }
+}
+
+void addRegularDash(std::vector<DashRange>& ranges, const int32_t yOffset, AlphaImage& image) {
+ // Collapse any zero-length range
+ for (auto it = ranges.begin(); it != ranges.end();) {
+ if (it->isZeroLength) {
+ ranges.erase(it);
+ } else { ++it; }
+ }
+
+ if (ranges.size() >= 2) {
+ // Collapse neighbouring same-type parts into a single part
+ for (auto curr = ranges.begin(), next = ranges.begin() + 1; curr != ranges.end() && next != ranges.end();) {
+ if (next->isDash == curr->isDash) {
+ next->left = curr->left;
+ ranges.erase(curr);
+ } else {
+ ++curr;
+ ++next;
+ }
+ }
+ }
+
+ DashRange& first = ranges.front();
+ DashRange& last = ranges.back();
+ if (first.isDash == last.isDash) {
+ first.left = last.left - image.size.width;
+ last.right = first.right + image.size.width;
+ }
+
+ int index = image.size.width * yOffset;
+ int currIndex = 0;
+ DashRange range = ranges[currIndex];
+
+ for (uint32_t x = 0; x < image.size.width; ++x) {
+ if (x / range.right > 1.0f) { range = ranges[++currIndex]; }
+
+ float distLeft = fabsf(x - range.left);
+ float distRight = fabsf(x - range.right);
+ float minDist = fminf(distLeft, distRight);
+ float signedDistance = range.isDash ? minDist : -minDist;
+
+ image.data[index + x] = static_cast<uint8_t>(fmaxf(0.0f, fminf(255.0f, signedDistance + 128.0f)));
+ }
+}
+
 LinePatternPos addDashPattern(AlphaImage& image,
  const int32_t yOffset,
  const std::vector<float>& dasharray,
  const LinePatternCap patternCap) {
  const uint8_t n = patternCap == LinePatternCap::Round ? 7 : 0;
- constexpr const uint8_t offset = 128;
 
  if (dasharray.size() < 2) {
  Log::Warning(Event::ParseStyle, "line dasharray requires at least two elements");
@@ -38,64 +138,17 @@ LinePatternPos addDashPattern(AlphaImage& image,
  }
 
  float stretch = image.size.width / length;
- float halfWidth = stretch * 0.5;
- // If dasharray has an odd length, both the first and last parts
- // are dashes and should be joined seamlessly.
- bool oddLength = dasharray.size() % 2 == 1;
+ std::vector<DashRange> ranges = getDashRanges(dasharray, stretch);
 
- for (int y = -n; y <= n; y++) {
- int row = yOffset + n + y;
- int index = image.size.width * row;
-
- float left = 0;
- float right = dasharray[0];
- unsigned int partIndex = 1;
-
- if (oddLength) {
- left -= dasharray.back();
- }
-
- for (uint32_t x = 0; x < image.size.width; x++) {
- while (right < x / stretch) {
- left = right;
- if (partIndex >= dasharray.size()) {
- return LinePatternPos();
- }
- right = right + dasharray[partIndex];
-
- if (oddLength && partIndex == dasharray.size() - 1) {
- right += dasharray.front();
- }
-
- partIndex++;
- }
-
- float distLeft = fabs(x - left * stretch);
- float distRight = fabs(x - right * stretch);
- float dist = fmin(distLeft, distRight);
- bool inside = (partIndex % 2) == 1;
- int signedDistance;
-
- if (patternCap == LinePatternCap::Round) {
- float distMiddle = n ? (float)y / n * (halfWidth + 1) : 0;
- if (inside) {
- float distEdge = halfWidth - fabs(distMiddle);
- signedDistance = sqrt(dist * dist + distEdge * distEdge);
- } else {
- signedDistance = halfWidth - sqrt(dist * dist + distMiddle * distMiddle);
- }
-
- } else {
- signedDistance = int((inside ? 1 : -1) * dist);
- }
-
- image.data[index + x] = fmax(0, fmin(255, signedDistance + offset));
- }
+ if (patternCap == LinePatternCap::Round) {
+ addRoundDash(ranges, yOffset, stretch, n, image);
+ } else {
+ addRegularDash(ranges, yOffset, image);
  }
 
  LinePatternPos position;
- position.y = (0.5 + yOffset + n) / image.size.height;
- position.height = (2.0 * n + 1) / image.size.height;
+ position.y = (0.5f + yOffset + n) / image.size.height;
+ position.height = (2.0f * n + 1) / image.size.height;
  position.width = length;
 
  return position;

src/mbgl/geometry/line_atlas.hpp

@@ -27,6 +27,13 @@ enum class LinePatternCap : bool {
  Round = true,
 };
 
+struct DashRange {
+ float left;
+ float right;
+ bool isDash;
+ bool isZeroLength;
+};
+
 class DashPatternTexture {
 public:
  DashPatternTexture(const std::vector<float>& from, const std::vector<float>& to, LinePatternCap);