Merge pull request #1229 from CesiumGS/vector-random-fix

Fix `ColorMode::Random` producing different results for each vector overlay tile rasterized

Author: kring

CHANGES.md

@@ -8,6 +8,7 @@
 - `ViewUpdateResult` now holds pointers to const `Tile` instances.
 - The `slowlyGetCurrentStates` and `slowlyGetPreviousStates` methods of `TreeTraversalState` now return the state map with a raw pointer to a constant node as the key, even if the node pointer type is a smart pointer.
 - `DebugTileStateDatabase::recordTileState` now expects the states to be provided as `std::unordered_map<const Tile*, TileSelectionState>` instead of `std::unordered_map<IntrusivePointer<Tile>, TileSelectionState>`.
+- `VectorRasterizer::drawPolyline` now takes a `std::vector` instead of a `std::span`.
 
 ##### Additions :tada:
 
@@ -19,6 +20,7 @@
 ##### Fixes :wrench:
 
 - Fixed a bug in `Tileset::updateViewGroupOffline` that would cause it to get stuck in an endless loop when invoked with no frustums.
+- Fixed `ColorMode::Random` in `VectorStyle` producing different results each time a raster overlay tile was rendered.
 - Fixed a bug in `IonRasterOverlay` that would cause unnecessary extra use of Bing Maps sessions when manually reloading the raster overlay after an expired token was automatically refreshed.
 - Fixed a bug that could lead to a crash when using raster overlays with tilesets that use "external tilesets", such as Google Photorealistic 3D Tiles.
 

CesiumVectorData/include/CesiumVectorData/VectorRasterizer.h

@@ -75,9 +75,8 @@ class VectorRasterizer {
    * should be specified in degrees.
    * @param style The \ref LineStyle to use when drawing the polyline.
    */
-  void drawPolyline(
-      const std::span<const glm::dvec3>& points,
-      const LineStyle& style);
+  void
+  drawPolyline(const std::vector<glm::dvec3>& points, const LineStyle& style);
 
   /**
    * @brief Rasterizes a `GeoJsonObject` to the canvas.

CesiumVectorData/include/CesiumVectorData/VectorStyle.h

@@ -40,8 +40,12 @@ struct ColorStyle {
    * For `ColorMode::Normal`, this just returns the value of `color`. For
    * `ColorMode::Random`, this returns a randomized value obtained based on
    * the rules described in \ref ColorMode.
+   *
+   * @param randomColorSeed The seed for the random color to be generated, if
+   * `colorMode` is set to `Random`. The same color will always be returned for
+   * a given seed, but nearby seeds will not usually return nearby colors.
    */
-  CesiumUtility::Color getColor() const;
+  CesiumUtility::Color getColor(size_t randomColorSeed = 0) const;
 };
 
 /** @brief The mode to use when interpreting a given line width. */

CesiumVectorData/src/VectorRasterizer.cpp

@@ -24,7 +24,6 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <span>
 #include <vector>
 
 using namespace CesiumGeospatial;
@@ -58,6 +57,10 @@ void setStrokeWidth(
         (bounds.computeWidth() * ellipsoid.getRadii().x));
   }
 }
+
+template <typename T> size_t seedForObject(const T& object, size_t base) {
+  return base ^ reinterpret_cast<size_t>(&object);
+}
 } // namespace
 
 VectorRasterizer::VectorRasterizer(
@@ -116,7 +119,7 @@ void VectorRasterizer::drawPolygon(
     this->_context.fillPolygon(
         vertices.data(),
         vertices.size(),
-        BLRgba32(style.fill->getColor().toRgba32()));
+        BLRgba32(style.fill->getColor(seedForObject(polygon, 13)).toRgba32()));
   }
 
   if (style.outline) {
@@ -128,7 +131,8 @@ void VectorRasterizer::drawPolygon(
     this->_context.strokePolygon(
         vertices.data(),
         vertices.size(),
-        BLRgba32(style.outline->getColor().toRgba32()));
+        BLRgba32(
+            style.outline->getColor(seedForObject(polygon, 31)).toRgba32()));
   }
 }
 
@@ -157,7 +161,7 @@ void VectorRasterizer::drawPolygon(
     this->_context.fillPolygon(
         vertices.data(),
         vertices.size(),
-        BLRgba32(style.fill->getColor().toRgba32()));
+        BLRgba32(style.fill->getColor(seedForObject(polygon, 13)).toRgba32()));
   }
 
   if (style.outline) {
@@ -169,12 +173,13 @@ void VectorRasterizer::drawPolygon(
     this->_context.strokePolygon(
         vertices.data(),
         vertices.size(),
-        BLRgba32(style.outline->getColor().toRgba32()));
+        BLRgba32(
+            style.outline->getColor(seedForObject(polygon, 31)).toRgba32()));
   }
 }
 
 void VectorRasterizer::drawPolyline(
-    const std::span<const glm::dvec3>& points,
+    const std::vector<glm::dvec3>& points,
     const LineStyle& style) {
   if (this->_finalized) {
     return;
@@ -197,7 +202,7 @@ void VectorRasterizer::drawPolyline(
   this->_context.strokePolyline(
       vertices.data(),
       vertices.size(),
-      BLRgba32(style.getColor().toRgba32()));
+      BLRgba32(style.getColor(seedForObject(points, 31)).toRgba32()));
 }
 
 void VectorRasterizer::drawGeoJsonObject(

CesiumVectorData/src/VectorStyle.cpp

@@ -1,26 +1,30 @@
 #include <CesiumUtility/Color.h>
 #include <CesiumVectorData/VectorStyle.h>
 
+#include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <optional>
-#include <random>
 
 using namespace CesiumUtility;
 
 namespace CesiumVectorData {
-Color ColorStyle::getColor() const {
+Color ColorStyle::getColor(size_t randomColorSeed) const {
   if (this->colorMode == ColorMode::Normal) {
     return this->color;
   }
 
-  std::random_device r;
-  std::mt19937 mt(r());
-  std::uniform_real_distribution<float> dist(0.0f, 1.0f);
+  std::hash<size_t> hash{};
+  size_t h = hash(randomColorSeed);
+
+  float r = uint8_t(h & 0xFF) / 255.0f;
+  float g = uint8_t((h >> 8) & 0xFF) / 255.0f;
+  float b = uint8_t((h >> 16) & 0xFF) / 255.0f;
 
   return Color{
-      (uint8_t)(dist(mt) * (float)this->color.r),
-      (uint8_t)(dist(mt) * (float)this->color.g),
-      (uint8_t)(dist(mt) * (float)this->color.b),
+      (uint8_t)(r * this->color.r),
+      (uint8_t)(g * this->color.g),
+      (uint8_t)(b * this->color.b),
       this->color.a};
 }
 VectorStyle::VectorStyle(const CesiumUtility::Color& color)

CesiumVectorData/test/TestVectorRasterizer.cpp

@@ -327,6 +327,40 @@ TEST_CASE("VectorRasterizer::rasterize") {
     writeImageToTgaFile(*asset, "styling.tga");
     checkFilesEqual(dir / "styling.tga", thisDir / "styling.tga");
   }
+
+  SUBCASE("Random color uses the same color across calls") {
+    CesiumUtility::IntrusivePointer<CesiumGltf::ImageAsset> asset;
+    asset.emplace();
+    asset->width = 1;
+    asset->height = 1;
+    asset->channels = 4;
+    asset->bytesPerChannel = 1;
+    asset->pixelData.resize(4, std::byte{255});
+
+    CartographicPolygon square(std::vector<glm::dvec2>{
+        glm::dvec2{Math::degreesToRadians(0.0), Math::degreesToRadians(0.0)},
+        glm::dvec2{Math::degreesToRadians(0.0), Math::degreesToRadians(1.0)},
+        glm::dvec2{Math::degreesToRadians(1.0), Math::degreesToRadians(1.0)},
+        glm::dvec2{Math::degreesToRadians(1.0), Math::degreesToRadians(0.0)},
+        glm::dvec2{Math::degreesToRadians(0.0), Math::degreesToRadians(0.0)}});
+
+    VectorStyle style;
+    style.polygon.fill =
+        ColorStyle{Color{0xff, 0x00, 0xaa, 0xff}, ColorMode::Random};
+
+    VectorRasterizer rasterizer(rect, asset);
+    rasterizer.drawPolygon(square, style.polygon);
+    rasterizer.finalize();
+
+    const uint32_t writtenColor =
+        *reinterpret_cast<uint32_t*>(asset->pixelData.data());
+    VectorRasterizer rasterizer2(rect, asset);
+    rasterizer2.drawPolygon(square, style.polygon);
+    rasterizer2.finalize();
+
+    CHECK(
+        *reinterpret_cast<uint32_t*>(asset->pixelData.data()) == writtenColor);
+  }
 }
 
 TEST_CASE("VectorRasterizer::rasterize benchmark" * doctest::skip(true)) {