Load color tables from settings

scwx-qt/source/scwx/qt/manager/settings_manager.cpp

@@ -21,6 +21,7 @@ namespace SettingsManager
 static const std::string logPrefix_ = "[scwx::qt::manager::settings_manager] ";
 
 static std::shared_ptr<settings::GeneralSettings> generalSettings_ = nullptr;
+static std::shared_ptr<settings::PaletteSettings> paletteSettings_ = nullptr;
 
 static boost::json::value ConvertSettingsToJson();
 static void               GenerateDefaultSettings();
@@ -79,11 +80,17 @@ std::shared_ptr<settings::GeneralSettings> general_settings()
    return generalSettings_;
 }
 
+std::shared_ptr<settings::PaletteSettings> palette_settings()
+{
+   return paletteSettings_;
+}
+
 static boost::json::value ConvertSettingsToJson()
 {
    boost::json::object settingsJson;
 
    settingsJson["general"] = generalSettings_->ToJson();
+   settingsJson["palette"] = paletteSettings_->ToJson();
 
    return settingsJson;
 }
@@ -93,6 +100,7 @@ static void GenerateDefaultSettings()
    BOOST_LOG_TRIVIAL(info) << logPrefix_ << "Generating default settings";
 
    generalSettings_ = settings::GeneralSettings::Create();
+   paletteSettings_ = settings::PaletteSettings::Create();
 }
 
 static bool LoadSettings(const boost::json::object& settingsJson)
@@ -103,6 +111,8 @@ static bool LoadSettings(const boost::json::object& settingsJson)
 
    generalSettings_ = settings::GeneralSettings::Load(
       settingsJson.if_contains("general"), jsonDirty);
+   paletteSettings_ = settings::PaletteSettings::Load(
+      settingsJson.if_contains("palette"), jsonDirty);
 
    return jsonDirty;
 }

scwx-qt/source/scwx/qt/manager/settings_manager.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <scwx/qt/settings/general_settings.hpp>
+#include <scwx/qt/settings/palette_settings.hpp>
 
 namespace scwx
 {
@@ -15,6 +16,7 @@ void Initialize();
 void ReadSettings(const std::string& settingsPath);
 
 std::shared_ptr<settings::GeneralSettings> general_settings();
+std::shared_ptr<settings::PaletteSettings> palette_settings();
 
 } // namespace SettingsManager
 } // namespace manager

scwx-qt/source/scwx/qt/map/map_widget.cpp

@@ -1,6 +1,7 @@
 #include <scwx/qt/map/map_widget.hpp>
 #include <scwx/qt/gl/gl.hpp>
 #include <scwx/qt/manager/radar_product_manager.hpp>
+#include <scwx/qt/manager/settings_manager.hpp>
 #include <scwx/qt/map/overlay_layer.hpp>
 #include <scwx/qt/map/radar_product_layer.hpp>
 #include <scwx/qt/map/radar_range_layer.hpp>
@@ -99,11 +100,13 @@ void MapWidget::SelectRadarProduct(common::Level2Product product)
 
    p->radarProductView_->Initialize();
 
-   QString colorTableFile = qgetenv("COLOR_TABLE");
-   if (!colorTableFile.isEmpty())
+   std::string colorTableFile =
+      manager::SettingsManager::palette_settings()->palette(
+         common::GetLevel2Palette(product));
+   if (!colorTableFile.empty())
    {
       std::shared_ptr<common::ColorTable> colorTable =
-         common::ColorTable::Load(colorTableFile.toUtf8().constData());
+         common::ColorTable::Load(colorTableFile);
       p->radarProductView_->LoadColorTable(colorTable);
    }
 

scwx-qt/source/scwx/qt/settings/general_settings.cpp

@@ -12,7 +12,7 @@ namespace settings
 
 static const std::string logPrefix_ = "[scwx::qt::settings::general_settings] ";
 
-static const std::string& DEFAULT_DEFAULT_RADAR_SITE = "KLSX";
+static const std::string DEFAULT_DEFAULT_RADAR_SITE = "KLSX";
 
 class GeneralSettingsImpl
 {
@@ -35,12 +35,12 @@ GeneralSettings::GeneralSettings(GeneralSettings&&) noexcept = default;
 GeneralSettings&
 GeneralSettings::operator=(GeneralSettings&&) noexcept = default;
 
-const std::string& GeneralSettings::default_radar_site()
+const std::string& GeneralSettings::default_radar_site() const
 {
    return p->defaultRadarSite_;
 }
 
-boost::json::value GeneralSettings::ToJson()
+boost::json::value GeneralSettings::ToJson() const
 {
    boost::json::object json;
 

scwx-qt/source/scwx/qt/settings/general_settings.hpp

@@ -26,9 +26,9 @@ public:
    GeneralSettings(GeneralSettings&&) noexcept;
    GeneralSettings& operator=(GeneralSettings&&) noexcept;
 
-   const std::string& default_radar_site();
+   const std::string& default_radar_site() const;
 
-   boost::json::value ToJson();
+   boost::json::value ToJson() const;
 
    static std::shared_ptr<GeneralSettings> Create();
    static std::shared_ptr<GeneralSettings> Load(const boost::json::value* json,

scwx-qt/source/scwx/qt/settings/palette_settings.cpp

@@ -0,0 +1,132 @@
+#include <scwx/qt/settings/palette_settings.hpp>
+#include <scwx/qt/util/json.hpp>
+
+#include <boost/log/trivial.hpp>
+
+namespace scwx
+{
+namespace qt
+{
+namespace settings
+{
+
+static const std::string logPrefix_ = "[scwx::qt::settings::palette_settings] ";
+
+static const std::vector<std::string> paletteNames_ = {
+   "BR", "BV", "SW", "ZDR", "PHI", "CC", "???"};
+
+static const std::string DEFAULT_KEY     = "Default";
+static const std::string DEFAULT_PALETTE = "";
+
+class PaletteSettingsImpl
+{
+public:
+   explicit PaletteSettingsImpl() {}
+
+   ~PaletteSettingsImpl() {}
+
+   void SetDefaults()
+   {
+      std::for_each(
+         paletteNames_.cbegin(),
+         paletteNames_.cend(),
+         [&](const std::string& name) { palette_[name] = DEFAULT_PALETTE; });
+   }
+
+   std::unordered_map<std::string, std::string> palette_;
+};
+
+PaletteSettings::PaletteSettings() : p(std::make_unique<PaletteSettingsImpl>())
+{
+}
+PaletteSettings::~PaletteSettings() = default;
+
+PaletteSettings::PaletteSettings(PaletteSettings&&) noexcept = default;
+PaletteSettings&
+PaletteSettings::operator=(PaletteSettings&&) noexcept = default;
+
+const std::string& PaletteSettings::palette(const std::string& name) const
+{
+   auto palette = p->palette_.find(name);
+
+   if (palette == p->palette_.cend())
+   {
+      palette = p->palette_.find("Default");
+   }
+
+   if (palette == p->palette_.cend())
+   {
+      return DEFAULT_PALETTE;
+   }
+
+   return palette->second;
+}
+
+boost::json::value PaletteSettings::ToJson() const
+{
+   boost::json::object json;
+
+   std::for_each(
+      paletteNames_.cbegin(),
+      paletteNames_.cend(),
+      [&](const std::string& name) { json[name] = p->palette_[name]; });
+
+   return json;
+}
+
+std::shared_ptr<PaletteSettings> PaletteSettings::Create()
+{
+   std::shared_ptr<PaletteSettings> generalSettings =
+      std::make_shared<PaletteSettings>();
+
+   generalSettings->p->SetDefaults();
+
+   return generalSettings;
+}
+
+std::shared_ptr<PaletteSettings>
+PaletteSettings::Load(const boost::json::value* json, bool& jsonDirty)
+{
+   std::shared_ptr<PaletteSettings> generalSettings =
+      std::make_shared<PaletteSettings>();
+
+   if (json != nullptr && json->is_object())
+   {
+      std::for_each(paletteNames_.cbegin(),
+                    paletteNames_.cend(),
+                    [&](const std::string& name) {
+                       jsonDirty |= !util::json::FromJsonString(
+                          json->as_object(),
+                          name,
+                          generalSettings->p->palette_[name],
+                          DEFAULT_PALETTE);
+                    });
+   }
+   else
+   {
+      if (json == nullptr)
+      {
+         BOOST_LOG_TRIVIAL(warning)
+            << logPrefix_ << "Key is not present, resetting to defaults";
+      }
+      else if (!json->is_object())
+      {
+         BOOST_LOG_TRIVIAL(warning)
+            << logPrefix_ << "Invalid json, resetting to defaults";
+      }
+
+      generalSettings->p->SetDefaults();
+      jsonDirty = true;
+   }
+
+   return generalSettings;
+}
+
+bool operator==(const PaletteSettings& lhs, const PaletteSettings& rhs)
+{
+   return lhs.p->palette_ == rhs.p->palette_;
+}
+
+} // namespace settings
+} // namespace qt
+} // namespace scwx

scwx-qt/source/scwx/qt/settings/palette_settings.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <boost/json.hpp>
+
+namespace scwx
+{
+namespace qt
+{
+namespace settings
+{
+
+class PaletteSettingsImpl;
+
+class PaletteSettings
+{
+public:
+   explicit PaletteSettings();
+   ~PaletteSettings();
+
+   PaletteSettings(const PaletteSettings&) = delete;
+   PaletteSettings& operator=(const PaletteSettings&) = delete;
+
+   PaletteSettings(PaletteSettings&&) noexcept;
+   PaletteSettings& operator=(PaletteSettings&&) noexcept;
+
+   const std::string& palette(const std::string& name) const;
+
+   boost::json::value ToJson() const;
+
+   static std::shared_ptr<PaletteSettings> Create();
+   static std::shared_ptr<PaletteSettings> Load(const boost::json::value* json,
+                                                bool& jsonDirty);
+
+   friend bool operator==(const PaletteSettings& lhs,
+                          const PaletteSettings& rhs);
+
+private:
+   std::unique_ptr<PaletteSettingsImpl> p;
+};
+
+} // namespace settings
+} // namespace qt
+} // namespace scwx

scwx-qt/source/scwx/qt/view/level2_product_view.cpp

@@ -156,14 +156,15 @@ void Level2ProductView::LoadColorTable(
 void Level2ProductView::UpdateColorTable()
 {
    if (p->momentDataBlock0_ == nullptr || //
-       p->colorTable_ == nullptr)
+       p->colorTable_ == nullptr ||       //
+       !p->colorTable_->IsValid())
    {
       // Nothing to update
       return;
    }
 
-   const float offset = p->momentDataBlock0_->offset();
-   const float scale  = p->momentDataBlock0_->scale();
+   float offset = p->momentDataBlock0_->offset();
+   float scale  = p->momentDataBlock0_->scale();
 
    if (p->savedColorTable_ == p->colorTable_ && //
        p->savedOffset_ == offset &&             //
@@ -173,10 +174,41 @@ void Level2ProductView::UpdateColorTable()
       return;
    }
 
-   std::vector<boost::gil::rgba8_pixel_t>& lut = p->colorTableLut_;
-   lut.resize(254);
+   uint16_t rangeMin;
+   uint16_t rangeMax;
 
-   auto dataRange = boost::irange<uint16_t>(2, 255);
+   switch (p->product_)
+   {
+   case common::Level2Product::Reflectivity:
+   case common::Level2Product::Velocity:
+   case common::Level2Product::SpectrumWidth:
+   case common::Level2Product::CorrelationCoefficient:
+   default:
+      rangeMin = 2;
+      rangeMax = 255;
+      break;
+
+   case common::Level2Product::DifferentialReflectivity:
+      rangeMin = 2;
+      rangeMax = 1058;
+      break;
+
+   case common::Level2Product::DifferentialPhase:
+      rangeMin = 2;
+      rangeMax = 1023;
+      break;
+
+   case common::Level2Product::ClutterFilterPowerRemoved:
+      rangeMin = 8;
+      rangeMax = 81;
+      break;
+   }
+
+   boost::integer_range<uint16_t> dataRange =
+      boost::irange<uint16_t>(rangeMin, rangeMax);
+
+   std::vector<boost::gil::rgba8_pixel_t>& lut = p->colorTableLut_;
+   lut.resize(rangeMax - rangeMin + 1);
 
    std::for_each(std::execution::par_unseq,
                  dataRange.begin(),