[gpx] Save bookmark color to gpx export (#11238)

* [gpx] Save bookmark color to gpx export
* [gpx] Code-review fixes
* [gpx] Use m_rgba to store initial color, reset on predefined color change
* [gpx] Move MapPredefinedColor to color parser
* [gpx] Adjust naming

Signed-off-by: cyber-toad <the.cyber.toad@proton.me>

data/test_data/gpx/export_test.gpx

@@ -15,6 +15,15 @@
 <wpt lat="48.209847" lon="16.376028">
   <name><![CDATA[Point cdata name ><&"]]></name>
   <desc><![CDATA[Point cdata desc ><&"]]></desc>
+  <extensions>
+    <xsi:gpx><color>#FF00FF00</color></xsi:gpx>
+  </extensions>
+</wpt>
+<wpt lat="48.209849" lon="16.376029">
+  <name>Point with color</name>
+  <extensions>
+    <xsi:gpx><color>#FFFFC800</color></xsi:gpx>
+  </extensions>
 </wpt>
 <trk>
   <name>Some random route</name>

data/test_data/gpx/point_with_predefined_color_1.gpx

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<gpx version="1.1" creator="Organic Maps" xmlns="http://www.topografix.com/GPX/1/1"
+    xmlns:gpxx="http://www.garmin.com/xmlschemas/GpxExtensions/v3"
+    xmlns:gpx_style="http://www.topografix.com/GPX/gpx_style/0/2"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.topografix.com/GPX/1/1 https://www.topografix.com/GPX/1/1/gpx.xsd http://www.topografix.com/GPX/gpx_style/0/2 https://www.topografix.com/GPX/gpx_style/0/2/gpx_style.xsd http://www.garmin.com/xmlschemas/GpxExtensions/v3 https://www.garmin.com/xmlschemas/GpxExtensionsv3.xsd">
+<metadata>
+</metadata>
+<wpt lat="48.209846" lon="16.376023">
+  <name>Point 1</name>
+  <desc>Point 1</desc>
+</wpt>
+</gpx>

data/test_data/gpx/point_with_predefined_color_2.gpx

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<gpx version="1.1" creator="Organic Maps" xmlns="http://www.topografix.com/GPX/1/1"
+    xmlns:gpxx="http://www.garmin.com/xmlschemas/GpxExtensions/v3"
+    xmlns:gpx_style="http://www.topografix.com/GPX/gpx_style/0/2"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.topografix.com/GPX/1/1 https://www.topografix.com/GPX/1/1/gpx.xsd http://www.topografix.com/GPX/gpx_style/0/2 https://www.topografix.com/GPX/gpx_style/0/2/gpx_style.xsd http://www.garmin.com/xmlschemas/GpxExtensions/v3 https://www.garmin.com/xmlschemas/GpxExtensionsv3.xsd">
+<metadata>
+</metadata>
+<wpt lat="48.209846" lon="16.376023">
+  <name>Point 1</name>
+  <desc>Point 1</desc>
+  <extensions>
+    <xsi:gpx><color>#FF0066CC</color></xsi:gpx>
+  </extensions>
+</wpt>
+</gpx>

libs/kml/color_parser.cpp

@@ -1,6 +1,7 @@
 #include "color_parser.hpp"
 
 #include "coding/hex.hpp"
+#include "types.hpp"
 
 #include "base/string_utils.hpp"
 
@@ -31,6 +32,97 @@ std::optional<uint32_t> ParseHexColor(std::string_view c)
   }
 }
 
+std::tuple<int, int, int> ExtractRGB(uint32_t rgbaColor)
+{
+  return {(rgbaColor >> 24) & 0xFF, (rgbaColor >> 16) & 0xFF, (rgbaColor >> 8) & 0xFF};
+}
+
+static int ColorDistance(uint32_t rgbaColor1, uint32_t rgbaColor2)
+{
+  auto const [r1, g1, b1] = ExtractRGB(rgbaColor1);
+  auto const [r2, g2, b2] = ExtractRGB(rgbaColor2);
+  return (r1 - r2) * (r1 - r2) + (g1 - g2) * (g1 - g2) + (b1 - b2) * (b1 - b2);
+}
+
+struct RGBAToGarmin
+{
+  uint32_t rgba;
+  std::string_view color;
+};
+
+auto constexpr kRGBAToGarmin = std::to_array<RGBAToGarmin>({{0x000000ff, "Black"},
+                                                            {0x8b0000ff, "DarkRed"},
+                                                            {0x006400ff, "DarkGreen"},
+                                                            {0xb5b820ff, "DarkYellow"},
+                                                            {0x00008bff, "DarkBlue"},
+                                                            {0x8b008bff, "DarkMagenta"},
+                                                            {0x008b8bff, "DarkCyan"},
+                                                            {0xccccccff, "LightGray"},
+                                                            {0x444444ff, "DarkGray"},
+                                                            {0xff0000ff, "Red"},
+                                                            {0x00ff00ff, "Green"},
+                                                            {0xffff00ff, "Yellow"},
+                                                            {0x0000ffff, "Blue"},
+                                                            {0xff00ffff, "Magenta"},
+                                                            {0x00ffffff, "Cyan"},
+                                                            {0xffffffff, "White"}});
+
+std::string_view MapGarminColor(uint32_t rgba)
+{
+  std::string_view closestColor = kRGBAToGarmin[0].color;
+  auto minDistance = std::numeric_limits<int>::max();
+  for (auto const & [rgbaGarmin, color] : kRGBAToGarmin)
+  {
+    auto const distance = ColorDistance(rgba, rgbaGarmin);
+
+    if (distance == 0)
+      return color;  // Exact match.
+
+    if (distance < minDistance)
+    {
+      minDistance = distance;
+      closestColor = color;
+    }
+  }
+  return closestColor;
+}
+
+struct RGBAToPredefined
+{
+  uint32_t rgba;
+  PredefinedColor predefinedColor;
+};
+
+static std::array<RGBAToPredefined, kOrderedPredefinedColors.size()> buildRGBAToPredefined()
+{
+  auto res = std::array<RGBAToPredefined, kOrderedPredefinedColors.size()>();
+  for (size_t i = 0; i < kOrderedPredefinedColors.size(); ++i)
+    res[i] = {ColorFromPredefinedColor(kOrderedPredefinedColors[i]).GetRGBA(), kOrderedPredefinedColors[i]};
+  return res;
+}
+
+auto const kRGBAToPredefined = buildRGBAToPredefined();
+
+PredefinedColor MapPredefinedColor(uint32_t rgba)
+{
+  auto closestColor = kRGBAToPredefined[0].predefinedColor;
+  auto minDistance = std::numeric_limits<int>::max();
+  for (auto const & [rgbaGarmin, color] : kRGBAToPredefined)
+  {
+    auto const distance = ColorDistance(rgba, rgbaGarmin);
+
+    if (distance == 0)
+      return color;  // Exact match.
+
+    if (distance < minDistance)
+    {
+      minDistance = distance;
+      closestColor = color;
+    }
+  }
+  return closestColor;
+}
+
 // Garmin extensions spec: https://www8.garmin.com/xmlschemas/GpxExtensionsv3.xsd
 // Color mapping: https://help.locusmap.eu/topic/extend-garmin-gpx-compatibilty
 std::optional<uint32_t> ParseGarminColor(std::string_view c)

libs/kml/color_parser.hpp

@@ -4,6 +4,8 @@
 #include <optional>
 #include <string_view>
 
+#include "types.hpp"
+
 namespace kml
 {
 
@@ -18,4 +20,7 @@ std::optional<uint32_t> ParseHexColor(std::string_view c);
 std::optional<uint32_t> ParseGarminColor(std::string_view c);
 std::optional<uint32_t> ParseOSMColor(std::string_view c);
 
+PredefinedColor MapPredefinedColor(uint32_t rgba);
+std::string_view MapGarminColor(uint32_t rgba);
+
 }  // namespace kml

libs/kml/kml_tests/gpx_tests.cpp

@@ -1,5 +1,6 @@
 #include "testing/testing.hpp"
 
+#include "kml/color_parser.hpp"
 #include "kml/serdes_common.hpp"
 #include "kml/serdes_gpx.hpp"
 
@@ -38,9 +39,8 @@ static std::string ReadFile(char const * testFile)
   return sourceFileText;
 }
 
-static std::string ReadFileAndSerialize(char const * testFile)
+static std::string Serialize(kml::FileData const & dataFromFile)
 {
-  kml::FileData const dataFromFile = LoadGpxFromFile(testFile);
   std::string resultBuffer;
   MemWriter<decltype(resultBuffer)> sink(resultBuffer);
   kml::gpx::SerializerGpx ser(dataFromFile);
@@ -48,6 +48,12 @@ static std::string ReadFileAndSerialize(char const * testFile)
   return resultBuffer;
 }
 
+static std::string ReadFileAndSerialize(char const * testFile)
+{
+  kml::FileData const dataFromFile = LoadGpxFromFile(testFile);
+  return Serialize(dataFromFile);
+}
+
 void ImportExportCompare(char const * testFile)
 {
   std::string const sourceFileText = ReadFile(testFile);
@@ -323,6 +329,20 @@ UNIT_TEST(Empty)
   TEST_EQUAL(0, dataFromFile.m_tracksData.size(), ());
 }
 
+UNIT_TEST(ImportExportWptColor)
+{
+  ImportExportCompare("test_data/gpx/point_with_predefined_color_2.gpx");
+}
+
+UNIT_TEST(PointWithPredefinedColor)
+{
+  kml::FileData dataFromFile = LoadGpxFromFile("test_data/gpx/point_with_predefined_color_1.gpx");
+  dataFromFile.m_bookmarksData[0].m_color.m_predefinedColor = kml::PredefinedColor::Blue;
+  auto const actual = Serialize(dataFromFile);
+  auto const expected = ReadFile("test_data/gpx/point_with_predefined_color_2.gpx");
+  TEST_EQUAL(expected, actual, ());
+}
+
 UNIT_TEST(OsmandColor1)
 {
   kml::FileData const dataFromFile = LoadGpxFromFile("test_data/gpx/osmand1.gpx");
@@ -394,11 +414,11 @@ UNIT_TEST(ParseFromString)
 
 UNIT_TEST(MapGarminColor)
 {
-  TEST_EQUAL("DarkCyan", kml::gpx::MapGarminColor(0x008b8bff), ());
+  TEST_EQUAL("DarkCyan", kml::MapGarminColor(0x008b8bff), ());
-  TEST_EQUAL("White", kml::gpx::MapGarminColor(0xffffffff), ());
+  TEST_EQUAL("White", kml::MapGarminColor(0xffffffff), ());
-  TEST_EQUAL("DarkYellow", kml::gpx::MapGarminColor(0xb4b820ff), ());
+  TEST_EQUAL("DarkYellow", kml::MapGarminColor(0xb4b820ff), ());
-  TEST_EQUAL("DarkYellow", kml::gpx::MapGarminColor(0xb6b820ff), ());
+  TEST_EQUAL("DarkYellow", kml::MapGarminColor(0xb6b820ff), ());
-  TEST_EQUAL("DarkYellow", kml::gpx::MapGarminColor(0xb5b721ff), ());
+  TEST_EQUAL("DarkYellow", kml::MapGarminColor(0xb5b721ff), ());
 }
 
 }  // namespace gpx_tests

libs/kml/serdes_gpx.cpp

@@ -80,11 +80,10 @@ bool GpxParser::MakeValid()
       // Set default name.
       if (m_name.empty())
         m_name = kml::PointToLineString(m_org);
-
+      if (m_color != kInvalidColor)
-      // Set default pin.
+        m_predefinedColor = MapPredefinedColor(m_color);
-      if (m_predefinedColor == PredefinedColor::None)
+      else
         m_predefinedColor = PredefinedColor::Red;
-
       return true;
     }
     return false;
@@ -428,61 +427,6 @@ std::string GpxParser::BuildDescription() const
   return m_description + "\n\n" + m_comment;
 }
 
-std::tuple<int, int, int> ExtractRGB(uint32_t color)
-{
-  return {(color >> 24) & 0xFF, (color >> 16) & 0xFF, (color >> 8) & 0xFF};
-}
-
-int ColorDistance(uint32_t color1, uint32_t color2)
-{
-  auto const [r1, g1, b1] = ExtractRGB(color1);
-  auto const [r2, g2, b2] = ExtractRGB(color2);
-  return (r1 - r2) * (r1 - r2) + (g1 - g2) * (g1 - g2) + (b1 - b2) * (b1 - b2);
-}
-
-struct RGBAToGarmin
-{
-  uint32_t rgba;
-  std::string_view color;
-};
-
-auto constexpr kRGBAToGarmin = std::to_array<RGBAToGarmin>({{0x000000ff, "Black"},
-                                                            {0x8b0000ff, "DarkRed"},
-                                                            {0x006400ff, "DarkGreen"},
-                                                            {0xb5b820ff, "DarkYellow"},
-                                                            {0x00008bff, "DarkBlue"},
-                                                            {0x8b008bff, "DarkMagenta"},
-                                                            {0x008b8bff, "DarkCyan"},
-                                                            {0xccccccff, "LightGray"},
-                                                            {0x444444ff, "DarkGray"},
-                                                            {0xff0000ff, "Red"},
-                                                            {0x00ff00ff, "Green"},
-                                                            {0xffff00ff, "Yellow"},
-                                                            {0x0000ffff, "Blue"},
-                                                            {0xff00ffff, "Magenta"},
-                                                            {0x00ffffff, "Cyan"},
-                                                            {0xffffffff, "White"}});
-
-std::string_view MapGarminColor(uint32_t rgba)
-{
-  std::string_view closestColor = kRGBAToGarmin[0].color;
-  auto minDistance = std::numeric_limits<int>::max();
-  for (auto const & [rgbaGarmin, color] : kRGBAToGarmin)
-  {
-    auto const distance = ColorDistance(rgba, rgbaGarmin);
-
-    if (distance == 0)
-      return color;  // Exact match.
-
-    if (distance < minDistance)
-    {
-      minDistance = distance;
-      closestColor = color;
-    }
-  }
-  return closestColor;
-}
-
 namespace
 {
 
@@ -524,6 +468,16 @@ void SaveCategoryData(Writer & writer, CategoryData const & categoryData)
   writer << "</metadata>\n";
 }
 
+uint32_t BookmarkColor(BookmarkData const & bookmarkData)
+{
+  auto const & [predefinedColor, rgba] = bookmarkData.m_color;
+  if (rgba != kInvalidColor)
+    return rgba;
+  if (predefinedColor != PredefinedColor::None && predefinedColor != PredefinedColor::Red)
+    return ColorFromPredefinedColor(predefinedColor).GetRGBA();
+  return kInvalidColor;
+}
+
 void SaveBookmarkData(Writer & writer, BookmarkData const & bookmarkData)
 {
   auto const [lat, lon] = mercator::ToLatLon(bookmarkData.m_point);
@@ -544,6 +498,14 @@ void SaveBookmarkData(Writer & writer, BookmarkData const & bookmarkData)
     SaveStringWithCDATA(writer, *description);
     writer << "</desc>\n";
   }
+  if (auto const color = BookmarkColor(bookmarkData); color != kInvalidColor)
+  {
+    writer << kIndent2 << "<extensions>\n";
+    writer << kIndent4 << "<xsi:gpx><color>#";
+    SaveColorToARGB(writer, color);
+    writer << "</color></xsi:gpx>\n";
+    writer << kIndent2 << "</extensions>\n";
+  }
   writer << "</wpt>\n";
 }
 
@@ -583,7 +545,7 @@ void SaveTrackData(Writer & writer, TrackData const & trackData)
   {
     writer << kIndent2 << "<extensions>\n";
     writer << kIndent4 << "<gpxx:TrackExtension><gpxx:DisplayColor>";
-    writer << MapGarminColor(color);
+    writer << kml::MapGarminColor(color);
     writer << "</gpxx:DisplayColor></gpxx:TrackExtension>\n";
     writer << kIndent4 << "<gpx_style:line><gpx_style:color>";
     SaveColorToRGB(writer, color);

libs/kml/serdes_gpx.hpp

@@ -106,8 +106,6 @@ private:
   std::string BuildDescription() const;
 };
 
-std::string_view MapGarminColor(uint32_t rgba);
-
 }  // namespace gpx
 
 class DeserializerGpx

libs/map/bookmark.cpp

@@ -58,6 +58,7 @@ std::string GetBookmarkIconType(kml::BookmarkIcon const & icon)
 
 std::string const kCustomImageProperty = "CustomImage";
 std::string const kHasElevationProfileProperty = "has_elevation_profile";
+int constexpr kInvalidColor = 0;
 }  // namespace
 
 Bookmark::Bookmark(m2::PointD const & ptOrg) : Base(ptOrg, UserMark::BOOKMARK), m_groupId(kml::kInvalidMarkGroupId)
@@ -185,6 +186,7 @@ void Bookmark::SetColor(kml::PredefinedColor color)
 {
   SetDirty();
   m_data.m_color.m_predefinedColor = color;
+  m_data.m_color.m_rgba = kInvalidColor;
 }
 
 std::string Bookmark::GetPreferredName() const