blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-29 18:50:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #503 from dpaulat/feature/product-load-status

Browse source 
Background Network Requests and No Data Available
This commit is contained in:
Dan Paulat 2025-09-05 21:34:45 -05:00 • committed by GitHub
commit 4fdf52b9b4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 819 additions and 338 deletions
Download patch file Download diff file Expand all files Collapse all files

1
scwx-qt/scwx-qt.cmake
View file

@ -234,6 +234,7 @@ set(HDR_TYPES source/scwx/qt/types/alert_types.hpp
source/scwx/qt/types/media_types.hpp
source/scwx/qt/types/qt_types.hpp
source/scwx/qt/types/radar_product_record.hpp
source/scwx/qt/types/radar_product_types.hpp
source/scwx/qt/types/text_event_key.hpp
source/scwx/qt/types/text_types.hpp
source/scwx/qt/types/texture_types.hpp

3
scwx-qt/source/scwx/qt/main/main.cpp
View file

@ -27,6 +27,7 @@
#include <boost/asio.hpp>
#include <fmt/format.h>
#include <QApplication>
#include <QLibraryInfo>
#include <QStandardPaths>
#include <QStyleHints>
#include <QSurfaceFormat>
@ -71,6 +72,8 @@ int main(int argc, char* argv[])
scwx::qt::main::kVersionString_,
scwx::qt::main::kBuildNumber_,
scwx::qt::main::kCommitString_);
logger_->info("Qt version {}",
QLibraryInfo::version().toString().toStdString());
InitializeOpenGL();

464
scwx-qt/source/scwx/qt/manager/radar_product_manager.cpp
View file

@ -15,6 +15,7 @@
#include <execution>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@ -36,11 +37,7 @@
# pragma warning(pop)
#endif
namespace scwx
{
namespace qt
{
namespace manager
namespace scwx::qt::manager
{
static const std::string logPrefix_ =
@ -109,21 +106,27 @@ public:
group, product, isChunks_, latestTime);
});
}
~ProviderManager() { threadPool_.join(); };
~ProviderManager() override
{
providerThreadPool_.stop();
providerThreadPool_.join();
};
std::string name() const;
void Disable();
void RefreshData();
void RefreshDataSync();
boost::asio::thread_pool threadPool_ {1u};
boost::asio::thread_pool providerThreadPool_ {1u};
const std::string radarId_;
const common::RadarProductGroup group_;
const std::string product_;
const bool isChunks_;
bool refreshEnabled_ {false};
boost::asio::steady_timer refreshTimer_ {threadPool_};
std::mutex refreshTimerMutex_ {};
const std::string radarId_;
const common::RadarProductGroup group_;
const std::string product_;
const bool isChunks_;
bool refreshEnabled_ {false};
boost::asio::steady_timer refreshTimer_ {providerThreadPool_};
std::mutex refreshTimerMutex_ {};
std::shared_ptr<provider::NexradDataProvider> provider_ {nullptr};
size_t refreshCount_ {0};
@ -184,11 +187,9 @@ public:
auto& [key, providerManager] = p;
providerManager->Disable();
});
lock.unlock();
// Lock other mutexes before destroying, ensure loading is complete
std::unique_lock loadLevel2DataLock {loadLevel2DataMutex_};
std::unique_lock loadLevel3DataLock {loadLevel3DataMutex_};
threadPool_.stop();
threadPool_.join();
}
@ -203,14 +204,14 @@ public:
boost::uuids::uuid uuid,
const std::set<std::shared_ptr<ProviderManager>>& providerManagers,
bool enabled);
void RefreshData(std::shared_ptr<ProviderManager> providerManager);
void RefreshDataSync(std::shared_ptr<ProviderManager> providerManager);
std::map<std::chrono::system_clock::time_point,
std::shared_ptr<types::RadarProductRecord>>
std::tuple<std::map<std::chrono::system_clock::time_point,
std::shared_ptr<types::RadarProductRecord>>,
types::RadarProductLoadStatus>
GetLevel2ProductRecords(std::chrono::system_clock::time_point time);
std::tuple<std::shared_ptr<types::RadarProductRecord>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
GetLevel3ProductRecord(const std::string& product,
std::chrono::system_clock::time_point time);
std::shared_ptr<types::RadarProductRecord>
@ -224,15 +225,24 @@ public:
std::mutex& mutex,
std::chrono::system_clock::time_point time);
void
LoadProviderData(std::chrono::system_clock::time_point time,
std::shared_ptr<ProviderManager> providerManager,
RadarProductRecordMap& recordMap,
std::shared_mutex& recordMutex,
std::mutex& loadDataMutex,
const std::shared_ptr<request::NexradFileRequest>& request);
void PopulateLevel2ProductTimes(std::chrono::system_clock::time_point time);
LoadProviderData(std::chrono::system_clock::time_point time,
std::shared_ptr<ProviderManager> providerManager,
RadarProductRecordMap& recordMap,
std::shared_mutex& recordMutex,
std::mutex& loadDataMutex,
const std::shared_ptr<request::NexradFileRequest>& request);
bool AreLevel2ProductTimesPopulated(
std::chrono::system_clock::time_point time) const;
bool
AreLevel3ProductTimesPopulated(const std::string& product,
std::chrono::system_clock::time_point time);
void PopulateLevel2ProductTimes(std::chrono::system_clock::time_point time,
bool update = true);
void PopulateLevel3ProductTimes(const std::string& product,
std::chrono::system_clock::time_point time);
std::chrono::system_clock::time_point time,
bool update = true);
void UpdateAvailableProductsSync();
@ -243,11 +253,16 @@ public:
const float gateRangeOffset,
std::vector<float>& outputCoordinates);
static bool AreProductTimesPopulated(
const std::shared_ptr<ProviderManager>& providerManager,
std::chrono::system_clock::time_point time);
static void
PopulateProductTimes(std::shared_ptr<ProviderManager> providerManager,
RadarProductRecordMap& productRecordMap,
std::shared_mutex& productRecordMutex,
std::chrono::system_clock::time_point time);
std::chrono::system_clock::time_point time,
bool update);
static void
LoadNexradFile(CreateNexradFileFunction load,
@ -771,28 +786,27 @@ void RadarProductManagerImpl::EnableRefresh(
if (providerManager->refreshEnabled_ != enabled)
{
providerManager->refreshEnabled_ = enabled;
RefreshData(providerManager);
providerManager->RefreshData();
}
}
}
}
void RadarProductManagerImpl::RefreshData(
std::shared_ptr<ProviderManager> providerManager)
void ProviderManager::RefreshData()
{
logger_->trace("RefreshData: {}", providerManager->name());
logger_->trace("RefreshData: {}", name());
{
std::unique_lock lock(providerManager->refreshTimerMutex_);
providerManager->refreshTimer_.cancel();
const std::unique_lock lock(refreshTimerMutex_);
refreshTimer_.cancel();
}
boost::asio::post(threadPool_,
[=, this]()
boost::asio::post(providerThreadPool_,
[this]()
{
try
{
RefreshDataSync(providerManager);
RefreshDataSync();
}
catch (const std::exception& ex)
{
@ -801,27 +815,24 @@ void RadarProductManagerImpl::RefreshData(
});
}
void RadarProductManagerImpl::RefreshDataSync(
std::shared_ptr<ProviderManager> providerManager)
void ProviderManager::RefreshDataSync()
{
using namespace std::chrono_literals;
auto [newObjects, totalObjects] = providerManager->provider_->Refresh();
auto [newObjects, totalObjects] = provider_->Refresh();
// Level2 chunked data is updated quickly and uses a faster interval
const std::chrono::milliseconds fastRetryInterval =
providerManager->isChunks_ ? kFastRetryIntervalChunks_ :
kFastRetryInterval_;
isChunks_ ? kFastRetryIntervalChunks_ : kFastRetryInterval_;
const std::chrono::milliseconds slowRetryInterval =
providerManager->isChunks_ ? kSlowRetryIntervalChunks_ :
kSlowRetryInterval_;
isChunks_ ? kSlowRetryIntervalChunks_ : kSlowRetryInterval_;
std::chrono::milliseconds interval = fastRetryInterval;
if (totalObjects > 0)
{
auto latestTime = providerManager->provider_->FindLatestTime();
auto updatePeriod = providerManager->provider_->update_period();
auto lastModified = providerManager->provider_->last_modified();
auto latestTime = provider_->FindLatestTime();
auto updatePeriod = provider_->update_period();
auto lastModified = provider_->last_modified();
auto sinceLastModified = scwx::util::time::now() - lastModified;
// For the default interval, assume products are updated at a
@ -830,7 +841,11 @@ void RadarProductManagerImpl::RefreshDataSync(
interval = std::chrono::duration_cast<std::chrono::milliseconds>(
updatePeriod - sinceLastModified);
if (updatePeriod > 0s && sinceLastModified > updatePeriod * 5)
// Allow 5 update periods before considering the data stale
constexpr std::size_t kUpdatePeriodStaleCount = 5;
if (updatePeriod > 0s &&
sinceLastModified > updatePeriod * kUpdatePeriodStaleCount)
{
// If it has been at least 5 update periods since the file has
// been last modified, slow the retry period
@ -844,46 +859,43 @@ void RadarProductManagerImpl::RefreshDataSync(
if (newObjects > 0)
{
Q_EMIT providerManager->NewDataAvailable(
providerManager->group_, providerManager->product_, latestTime);
Q_EMIT NewDataAvailable(group_, product_, latestTime);
}
}
else if (providerManager->refreshEnabled_)
else if (refreshEnabled_)
{
logger_->info("[{}] No data found", providerManager->name());
logger_->info("[{}] No data found", name());
// If no data is found, retry at the slow retry interval
interval = slowRetryInterval;
}
std::unique_lock const lock(providerManager->refreshTimerMutex_);
std::unique_lock const lock(refreshTimerMutex_);
if (providerManager->refreshEnabled_)
if (refreshEnabled_)
{
logger_->trace(
"[{}] Scheduled refresh in {:%M:%S}",
providerManager->name(),
name(),
std::chrono::duration_cast<std::chrono::seconds>(interval));
{
providerManager->refreshTimer_.expires_after(interval);
providerManager->refreshTimer_.async_wait(
[=, this](const boost::system::error_code& e)
refreshTimer_.expires_after(interval);
refreshTimer_.async_wait(
[this](const boost::system::error_code& e)
{
if (e == boost::system::errc::success)
{
RefreshData(providerManager);
RefreshData();
}
else if (e == boost::asio::error::operation_aborted)
{
logger_->debug("[{}] Data refresh timer cancelled",
providerManager->name());
logger_->debug("[{}] Data refresh timer cancelled", name());
}
else
{
logger_->warn("[{}] Data refresh timer error: {}",
providerManager->name(),
e.message());
logger_->warn(
"[{}] Data refresh timer error: {}", name(), e.message());
}
});
}
@ -934,32 +946,32 @@ RadarProductManager::GetActiveVolumeTimes(
[&](const std::shared_ptr<provider::NexradDataProvider>& provider)
{
// For yesterday, today and tomorrow (in parallel)
std::for_each(std::execution::par,
dates.begin(),
dates.end(),
[&](const auto& date)
{
// Don't query for a time point in the future
if (date > scwx::util::time::now())
{
return;
}
std::for_each(
std::execution::par,
dates.begin(),
dates.end(),
[&](const auto& date)
{
// Don't query for a time point in the future
if (date > scwx::util::time::now())
{
return;
}
// Query the provider for volume time points
auto timePoints = provider->GetTimePointsByDate(date);
// Query the provider for volume time points
auto timePoints = provider->GetTimePointsByDate(date, true);
// TODO: Note, this will miss volume times present in
// Level 2 products with a second scan
// TODO: Note, this will miss volume times present in Level 2
// products with a second scan
// Lock the merged volume time list
std::unique_lock volumeTimesLock {volumeTimesMutex};
// Lock the merged volume time list
const std::unique_lock volumeTimesLock {volumeTimesMutex};
// Copy time points to the merged list
std::copy(
timePoints.begin(),
timePoints.end(),
std::inserter(volumeTimes, volumeTimes.end()));
});
// Copy time points to the merged list
std::copy(timePoints.begin(),
timePoints.end(),
std::inserter(volumeTimes, volumeTimes.end()));
});
});
// Return merged volume times list
@ -1202,21 +1214,70 @@ void RadarProductManagerImpl::LoadNexradFile(
}
}
bool RadarProductManagerImpl::AreLevel2ProductTimesPopulated(
std::chrono::system_clock::time_point time) const
{
return AreProductTimesPopulated(level2ProviderManager_, time);
}
bool RadarProductManagerImpl::AreLevel3ProductTimesPopulated(
const std::string& product, std::chrono::system_clock::time_point time)
{
// Get provider manager
const auto level3ProviderManager = GetLevel3ProviderManager(product);
return AreProductTimesPopulated(level3ProviderManager, time);
}
bool RadarProductManagerImpl::AreProductTimesPopulated(
const std::shared_ptr<ProviderManager>& providerManager,
std::chrono::system_clock::time_point time)
{
auto today = std::chrono::floor<std::chrono::days>(time);
bool productTimesPopulated = true;
// Assume a query for the epoch is a query for now
if (today == std::chrono::system_clock::time_point {})
{
today = std::chrono::floor<std::chrono::days>(scwx::util::time::now());
}
const auto yesterday = today - std::chrono::days {1};
const auto tomorrow = today + std::chrono::days {1};
const auto dates = {yesterday, today, tomorrow};
for (auto& date : dates)
{
// Don't query for a time point in the future
if (date > scwx::util::time::now())
{
continue;
}
if (!providerManager->provider_->IsDateCached(date))
{
productTimesPopulated = false;
}
}
return productTimesPopulated;
}
void RadarProductManagerImpl::PopulateLevel2ProductTimes(
std::chrono::system_clock::time_point time)
std::chrono::system_clock::time_point time, bool update)
{
PopulateProductTimes(level2ProviderManager_,
level2ProductRecords_,
level2ProductRecordMutex_,
time);
PopulateProductTimes(level2ChunksProviderManager_,
level2ProductRecords_,
level2ProductRecordMutex_,
time);
time,
update);
}
void RadarProductManagerImpl::PopulateLevel3ProductTimes(
const std::string& product, std::chrono::system_clock::time_point time)
const std::string& product,
std::chrono::system_clock::time_point time,
bool update)
{
// Get provider manager
auto level3ProviderManager = GetLevel3ProviderManager(product);
@ -1229,21 +1290,38 @@ void RadarProductManagerImpl::PopulateLevel3ProductTimes(
PopulateProductTimes(level3ProviderManager,
level3ProductRecords,
level3ProductRecordMutex_,
time);
time,
update);
}
void RadarProductManagerImpl::PopulateProductTimes(
std::shared_ptr<ProviderManager> providerManager,
RadarProductRecordMap& productRecordMap,
std::shared_mutex& productRecordMutex,
std::chrono::system_clock::time_point time)
std::chrono::system_clock::time_point time,
bool update)
{
const auto today = std::chrono::floor<std::chrono::days>(time);
if (update)
{
logger_->debug("Populating product times: {}, {}, {}",
common::GetRadarProductGroupName(providerManager->group_),
providerManager->product_,
scwx::util::time::TimeString(time));
}
else
{
logger_->trace("Populating cached product times: {}, {}, {}",
common::GetRadarProductGroupName(providerManager->group_),
providerManager->product_,
scwx::util::time::TimeString(time));
}
// Don't query for the epoch
auto today = std::chrono::floor<std::chrono::days>(time);
// Assume a query for the epoch is a query for now
if (today == std::chrono::system_clock::time_point {})
{
return;
today = std::chrono::floor<std::chrono::days>(scwx::util::time::now());
}
const auto yesterday = today - std::chrono::days {1};
@ -1267,7 +1345,8 @@ void RadarProductManagerImpl::PopulateProductTimes(
// Query the provider for volume time points
auto timePoints =
providerManager->provider_->GetTimePointsByDate(date);
providerManager->provider_->GetTimePointsByDate(date,
update);
// Lock the merged volume time list
std::unique_lock volumeTimesLock {volumeTimesMutex};
@ -1293,8 +1372,9 @@ void RadarProductManagerImpl::PopulateProductTimes(
});
}
std::map<std::chrono::system_clock::time_point,
std::shared_ptr<types::RadarProductRecord>>
std::tuple<std::map<std::chrono::system_clock::time_point,
std::shared_ptr<types::RadarProductRecord>>,
types::RadarProductLoadStatus>
RadarProductManagerImpl::GetLevel2ProductRecords(
std::chrono::system_clock::time_point time)
{
@ -1302,9 +1382,40 @@ RadarProductManagerImpl::GetLevel2ProductRecords(
std::shared_ptr<types::RadarProductRecord>>
records {};
std::vector<RadarProductRecordMap::const_pointer> recordPtrs {};
types::RadarProductLoadStatus status {
types::RadarProductLoadStatus::ListingProducts};
std::size_t recordPtrCount = 0u;
std::size_t recordCount = 0u;
// Ensure Level 2 product records are updated
PopulateLevel2ProductTimes(time);
if (!AreLevel2ProductTimesPopulated(time))
{
logger_->debug("Level 2 product times need populated: {}",
scwx::util::time::TimeString(time));
// Populate level 2 product times asynchronously
boost::asio::post(threadPool_,
[time, this]()
{
// Populate product times
PopulateLevel2ProductTimes(time);
// Signal finished
Q_EMIT self_->ProductTimesPopulated(
common::RadarProductGroup::Level2, "", time);
});
// Return listing products status
return {records, status};
}
else
{
PopulateLevel2ProductTimes(time, false);
}
// Advance to loading product
status = types::RadarProductLoadStatus::LoadingProduct;
{
std::shared_lock lock {level2ProductRecordMutex_};
@ -1343,9 +1454,29 @@ RadarProductManagerImpl::GetLevel2ProductRecords(
if (recordPtr != nullptr)
{
using namespace std::chrono_literals;
// Don't check for an exact time match for level 2 products
recordTime = recordPtr->first;
record = recordPtr->second.lock();
if (
// For latest data, ensure it is from the last 24 hours
(time == std::chrono::system_clock::time_point {} &&
(recordTime > scwx::util::time::now() - 24h ||
recordTime == time)) ||
// For time queries, ensure data is within 24 hours of the request
(time != std::chrono::system_clock::time_point {} &&
std::chrono::abs(recordTime - time) < 24h))
{
record = recordPtr->second.lock();
++recordPtrCount;
}
else
{
// Reset the record
recordPtr = nullptr;
recordTime = time;
}
}
if (recordPtr != nullptr && record == nullptr &&
@ -1368,29 +1499,73 @@ RadarProductManagerImpl::GetLevel2ProductRecords(
});
self_->LoadLevel2Data(recordTime, request);
// Status is already set to LoadingProduct
}
if (record != nullptr)
{
// Return valid records
records.insert_or_assign(recordTime, record);
++recordCount;
}
}
return records;
if (recordPtrCount == 0)
{
// If all records are empty, the product is not available
status = types::RadarProductLoadStatus::ProductNotAvailable;
}
else if (recordCount == recordPtrCount)
{
// If all records were populated, the product has been loaded
status = types::RadarProductLoadStatus::ProductLoaded;
}
return {records, status};
}
std::tuple<std::shared_ptr<types::RadarProductRecord>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
RadarProductManagerImpl::GetLevel3ProductRecord(
const std::string& product, std::chrono::system_clock::time_point time)
{
std::shared_ptr<types::RadarProductRecord> record {nullptr};
RadarProductRecordMap::const_pointer recordPtr {nullptr};
std::chrono::system_clock::time_point recordTime {time};
types::RadarProductLoadStatus status {
types::RadarProductLoadStatus::ListingProducts};
// Ensure Level 3 product records are updated
PopulateLevel3ProductTimes(product, time);
if (!AreLevel3ProductTimesPopulated(product, time))
{
logger_->debug("Level 3 product times need populated: {}, {}",
product,
scwx::util::time::TimeString(time));
// Populate level 3 product times asynchronously
boost::asio::post(threadPool_,
[product, time, this]()
{
// Populate product times
PopulateLevel3ProductTimes(product, time);
// Signal finished
Q_EMIT self_->ProductTimesPopulated(
common::RadarProductGroup::Level3, product, time);
});
// Return listing products status
return {record, recordTime, status};
}
else
{
PopulateLevel3ProductTimes(product, time, false);
}
// Advance to loading product
status = types::RadarProductLoadStatus::LoadingProduct;
std::unique_lock lock {level3ProductRecordMutex_};
@ -1415,9 +1590,27 @@ RadarProductManagerImpl::GetLevel3ProductRecord(
if (recordPtr != nullptr)
{
using namespace std::chrono_literals;
// Don't check for an exact time match for level 3 products
recordTime = recordPtr->first;
record = recordPtr->second.lock();
if (
// For latest data, ensure it is from the last 24 hours
(time == std::chrono::system_clock::time_point {} &&
(recordTime > scwx::util::time::now() - 24h || recordTime == time)) ||
// For time queries, ensure data is within 24 hours of the request
(time != std::chrono::system_clock::time_point {} &&
std::chrono::abs(recordTime - time) < 24h))
{
record = recordPtr->second.lock();
}
else
{
// Reset the record
recordPtr = nullptr;
recordTime = time;
}
}
if (recordPtr != nullptr && record == nullptr &&
@ -1440,9 +1633,22 @@ RadarProductManagerImpl::GetLevel3ProductRecord(
});
self_->LoadLevel3Data(product, recordTime, request);
// Status is already set to LoadingProduct
}
return {record, recordTime};
if (recordPtr == nullptr)
{
// If the record is empty, the product is not available
status = types::RadarProductLoadStatus::ProductNotAvailable;
}
else if (record != nullptr)
{
// If the record was populated, the product has been loaded
status = types::RadarProductLoadStatus::ProductLoaded;
}
return {record, recordTime, status};
}
std::shared_ptr<types::RadarProductRecord>
@ -1543,7 +1749,8 @@ void RadarProductManagerImpl::UpdateRecentRecords(
std::tuple<std::shared_ptr<wsr88d::rda::ElevationScan>,
float,
std::vector<float>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
RadarProductManager::GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
float elevation,
std::chrono::system_clock::time_point time)
@ -1552,6 +1759,8 @@ RadarProductManager::GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
float elevationCut = 0.0f;
std::vector<float> elevationCuts {};
std::chrono::system_clock::time_point foundTime {};
types::RadarProductLoadStatus loadStatus {
types::RadarProductLoadStatus::ProductNotLoaded};
const bool isEpox = time == std::chrono::system_clock::time_point {};
bool needArchive = true;
@ -1587,6 +1796,7 @@ RadarProductManager::GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
if (foundTime >= firstValidChunkTime)
{
needArchive = false;
loadStatus = types::RadarProductLoadStatus::ProductLoaded;
}
}
}
@ -1594,7 +1804,11 @@ RadarProductManager::GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
// It is not in the chunk provider, so get it from the archive
if (needArchive)
{
auto records = p->GetLevel2ProductRecords(time);
std::map<std::chrono::system_clock::time_point,
std::shared_ptr<types::RadarProductRecord>>
records;
std::tie(records, loadStatus) = p->GetLevel2ProductRecords(time);
for (auto& recordPair : records)
{
auto& record = recordPair.second;
@ -1639,25 +1853,35 @@ RadarProductManager::GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
}
}
return {radarData, elevationCut, elevationCuts, foundTime};
if (loadStatus == types::RadarProductLoadStatus::ProductLoaded &&
radarData == nullptr)
{
// If all data was available for the time point, but there is no matching
// radar data, consider this as no product available
loadStatus = types::RadarProductLoadStatus::ProductNotAvailable;
}
return {radarData, elevationCut, elevationCuts, foundTime, loadStatus};
}
std::tuple<std::shared_ptr<wsr88d::rpg::Level3Message>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
RadarProductManager::GetLevel3Data(const std::string& product,
std::chrono::system_clock::time_point time)
{
std::shared_ptr<wsr88d::rpg::Level3Message> message = nullptr;
types::RadarProductLoadStatus status {};
std::shared_ptr<types::RadarProductRecord> record;
std::tie(record, time) = p->GetLevel3ProductRecord(product, time);
std::tie(record, time, status) = p->GetLevel3ProductRecord(product, time);
if (record != nullptr)
{
message = record->level3_file()->message();
}
return {message, time};
return {message, time, status};
}
common::Level3ProductCategoryMap
@ -1809,6 +2033,4 @@ RadarProductManager::Instance(const std::string& radarSite)
#include "radar_product_manager.moc"
} // namespace manager
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::manager

25
scwx-qt/source/scwx/qt/manager/radar_product_manager.hpp
View file

@ -5,23 +5,19 @@
#include <scwx/qt/config/radar_site.hpp>
#include <scwx/qt/request/nexrad_file_request.hpp>
#include <scwx/qt/types/radar_product_record.hpp>
#include <scwx/qt/types/radar_product_types.hpp>
#include <scwx/util/time.hpp>
#include <scwx/wsr88d/ar2v_file.hpp>
#include <scwx/wsr88d/level3_file.hpp>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>
#include <boost/uuid/nil_generator.hpp>
#include <QObject>
namespace scwx
{
namespace qt
{
namespace manager
namespace scwx::qt::manager
{
class RadarProductManagerImpl;
@ -89,12 +85,13 @@ public:
* @param [in] time Radar product time
*
* @return Level 2 radar data, selected elevation cut, available elevation
* cuts and selected time
* cuts, selected time and product load status
*/
std::tuple<std::shared_ptr<wsr88d::rda::ElevationScan>,
float,
std::vector<float>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
GetLevel2Data(wsr88d::rda::DataBlockType dataBlockType,
float elevation,
std::chrono::system_clock::time_point time = {});
@ -105,10 +102,11 @@ public:
* @param [in] product Radar product name
* @param [in] time Radar product time
*
* @return Level 3 message data and selected time
* @return Level 3 message data, selected time and product load status
*/
std::tuple<std::shared_ptr<wsr88d::rpg::Level3Message>,
std::chrono::system_clock::time_point>
std::chrono::system_clock::time_point,
types::RadarProductLoadStatus>
GetLevel3Data(const std::string& product,
std::chrono::system_clock::time_point time = {});
@ -151,6 +149,9 @@ signals:
bool isChunks,
std::chrono::system_clock::time_point latestTime);
void IncomingLevel2ElevationChanged(std::optional<float> incomingElevation);
void ProductTimesPopulated(common::RadarProductGroup group,
const std::string& product,
std::chrono::system_clock::time_point queryTime);
private:
std::unique_ptr<RadarProductManagerImpl> p;
@ -158,6 +159,4 @@ private:
friend class RadarProductManagerImpl;
};
} // namespace manager
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::manager

4
scwx-qt/source/scwx/qt/manager/timeline_manager.cpp
View file

@ -53,8 +53,10 @@ public:
// Lock mutexes before destroying
std::unique_lock animationTimerLock {animationTimerMutex_};
animationTimer_.cancel();
animationTimerLock.unlock();
std::unique_lock selectTimeLock {selectTimeMutex_};
selectThreadPool_.join();
playThreadPool_.join();
}
TimelineManager* self_;

16
scwx-qt/source/scwx/qt/map/alert_layer.cpp
View file

@ -6,8 +6,8 @@
#include <scwx/qt/util/color.hpp>
#include <scwx/qt/util/tooltip.hpp>
#include <scwx/util/logger.hpp>
#include <scwx/util/time.hpp>
#include <atomic>
#include <chrono>
#include <mutex>
#include <ranges>
@ -15,6 +15,7 @@
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <boost/algorithm/string/join.hpp>
#include <boost/asio/system_timer.hpp>
@ -22,7 +23,6 @@
#include <boost/container/stable_vector.hpp>
#include <boost/container_hash/hash.hpp>
#include <QEvent>
#include <utility>
namespace scwx::qt::map
{
@ -153,9 +153,11 @@ public:
~Impl()
{
std::unique_lock refreshLock(refreshMutex_);
refreshEnabled_ = false;
refreshTimer_.cancel();
refreshLock.unlock();
threadPool_.stop();
threadPool_.join();
receiver_ = nullptr;
@ -213,6 +215,7 @@ public:
AlertLayer* self_;
std::atomic<bool> refreshEnabled_ {true};
boost::asio::system_timer refreshTimer_ {threadPool_};
std::mutex refreshMutex_;
@ -582,7 +585,8 @@ void AlertLayer::Impl::ScheduleRefresh()
// Expires at the top of the next minute
std::chrono::system_clock::time_point now =
std::chrono::floor<std::chrono::minutes>(scwx::util::time::now());
std::chrono::floor<std::chrono::minutes>(
std::chrono::system_clock::now());
refreshTimer_.expires_at(now + 1min);
refreshTimer_.async_wait(
@ -599,7 +603,11 @@ void AlertLayer::Impl::ScheduleRefresh()
else
{
Q_EMIT self_->NeedsRendering();
ScheduleRefresh();
if (refreshEnabled_)
{
ScheduleRefresh();
}
}
});
}

193
scwx-qt/source/scwx/qt/map/overlay_layer.cpp
View file

@ -92,8 +92,15 @@ public:
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void RenderProductName(const std::shared_ptr<MapContext>& mapContext);
void
RenderProductDetails(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params);
void RenderAttribution(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params);
void SetupGeoIcons();
void SetCusorLocation(common::Coordinate coordinate);
void SetCursorLocation(common::Coordinate coordinate);
OverlayLayer* self_;
@ -173,7 +180,7 @@ OverlayLayer::~OverlayLayer()
p->cursorScaleConnection_.disconnect();
}
void OverlayLayer::Impl::SetCusorLocation(common::Coordinate coordinate)
void OverlayLayer::Impl::SetCursorLocation(common::Coordinate coordinate)
{
geoIcons_->SetIconLocation(
cursorIcon_, coordinate.latitude_, coordinate.longitude_);
@ -388,7 +395,7 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
p->geoIcons_->SetIconVisible(p->cursorIcon_, cursorIconVisible);
if (cursorIconVisible)
{
p->SetCusorLocation(mapContext->mouse_coordinate());
p->SetCursorLocation(mapContext->mouse_coordinate());
}
// Location Icon
@ -425,6 +432,58 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
}
}
p->RenderProductName(mapContext);
p->RenderProductDetails(mapContext, params);
// Map Center Icon
if (params.width != p->lastWidth_ || params.height != p->lastHeight_)
{
static constexpr double xPosition = 0.5;
static constexpr double yPosition = 0.5;
// Draw the icon in the center of the widget
p->icons_->SetIconLocation(p->mapCenterIcon_,
params.width * xPosition,
params.height * yPosition);
}
p->icons_->SetIconVisible(p->mapCenterIcon_,
generalSettings.show_map_center().GetValue());
const QMargins colorTableMargins = mapContext->color_table_margins();
if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_)
{
static constexpr int xOffset = 10;
static constexpr int yOffset = 10;
// Draw map logo with a 10x10 indent from the bottom left
p->icons_->SetIconLocation(p->mapLogoIcon_,
colorTableMargins.left() + xOffset,
colorTableMargins.bottom() + yOffset);
}
p->icons_->SetIconVisible(p->mapLogoIcon_,
generalSettings.show_map_logo().GetValue());
DrawLayer::RenderWithoutImGui(params);
p->RenderAttribution(mapContext, params);
p->firstRender_ = false;
p->lastWidth_ = params.width;
p->lastHeight_ = params.height;
p->lastBearing_ = params.bearing;
p->lastFontSize_ = ImGui::GetFontSize();
p->lastColorTableMargins_ = colorTableMargins;
ImGuiFrameEnd();
SCWX_GL_CHECK_ERROR();
}
void OverlayLayer::Impl::RenderProductName(
const std::shared_ptr<MapContext>& mapContext)
{
auto radarProductView = mapContext->radar_product_view();
if (radarProductView != nullptr)
{
// Render product name
@ -456,14 +515,68 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
ImGui::End();
}
}
}
if (p->sweepTimeString_.length() > 0)
void OverlayLayer::Impl::RenderProductDetails(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
auto radarProductView = mapContext->radar_product_view();
ImGui::SetNextWindowPos(ImVec2 {static_cast<float>(params.width), 0.0f},
ImGuiCond_Always,
ImVec2 {1.0f, 0.0f});
bool productNotAvailable = false;
types::RadarProductLoadStatus newLoadStatus =
types::RadarProductLoadStatus::ProductNotLoaded;
if (radarProductView != nullptr)
{
newLoadStatus = radarProductView->load_status();
switch (newLoadStatus)
{
case types::RadarProductLoadStatus::ProductNotAvailable:
productNotAvailable = true;
break;
default:
productNotAvailable = false;
}
}
if (productNotAvailable)
{
ImGui::Begin("Product Not Available",
nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_AlwaysAutoResize);
ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(255, 0, 0, 255));
ImGui::TextUnformatted("NO DATA AVAILABLE");
ImGui::PopStyleColor();
if (ImGui::BeginItemTooltip())
{
static constexpr float kFontSizeFactor_ = 20.0f;
static constexpr double kMaxWidthPercent_ = 0.8;
ImGui::PushTextWrapPos(
std::min(ImGui::GetFontSize() * kFontSizeFactor_,
static_cast<float>(params.width * kMaxWidthPercent_)));
ImGui::TextUnformatted(
"No data found for the selected product and time. Please select a "
"different product, or update your time selection.");
ImGui::PopTextWrapPos();
ImGui::EndTooltip();
}
ImGui::End();
}
else if (sweepTimeString_.length() > 0)
{
// Render time
ImGui::SetNextWindowPos(ImVec2 {static_cast<float>(params.width), 0.0f},
ImGuiCond_Always,
ImVec2 {1.0f, 0.0f});
ImGui::Begin("Sweep Time",
ImGui::Begin("Product Details",
nullptr,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_AlwaysAutoResize);
@ -471,12 +584,12 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
if (radarProductView != nullptr && ImGui::IsWindowHovered())
{
// Show a detailed product description when the sweep time is hovered
p->sweepTimePicked_ = true;
sweepTimePicked_ = true;
auto fields = radarProductView->GetDescriptionFields();
if (fields.empty())
{
ImGui::TextUnformatted(p->sweepTimeString_.c_str());
ImGui::TextUnformatted(sweepTimeString_.c_str());
}
else
{
@ -496,34 +609,19 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
}
else
{
ImGui::TextUnformatted(p->sweepTimeString_.c_str());
ImGui::TextUnformatted(sweepTimeString_.c_str());
}
ImGui::End();
}
}
// Map Center Icon
if (params.width != p->lastWidth_ || params.height != p->lastHeight_)
{
// Draw the icon in the center of the widget
p->icons_->SetIconLocation(
p->mapCenterIcon_, params.width / 2.0, params.height / 2.0);
}
p->icons_->SetIconVisible(p->mapCenterIcon_,
generalSettings.show_map_center().GetValue());
void OverlayLayer::Impl::RenderAttribution(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
const QMargins colorTableMargins = mapContext->color_table_margins();
if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_)
{
// Draw map logo with a 10x10 indent from the bottom left
p->icons_->SetIconLocation(p->mapLogoIcon_,
10 + colorTableMargins.left(),
10 + colorTableMargins.bottom());
}
p->icons_->SetIconVisible(p->mapLogoIcon_,
generalSettings.show_map_logo().GetValue());
DrawLayer::RenderWithoutImGui(params);
auto& generalSettings = settings::GeneralSettings::Instance();
auto mapCopyrights = mapContext->map_copyrights();
if (mapCopyrights.length() > 0 &&
@ -532,13 +630,19 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
auto attributionFont = manager::FontManager::Instance().GetImGuiFont(
types::FontCategory::Attribution);
ImGui::SetNextWindowPos(ImVec2 {static_cast<float>(params.width),
static_cast<float>(params.height) -
colorTableMargins.bottom()},
ImGuiCond_Always,
ImVec2 {1.0f, 1.0f});
ImGui::SetNextWindowBgAlpha(0.5f);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2 {3.0f, 2.0f});
static constexpr float kWindowBgAlpha_ = 0.5f;
static constexpr float kWindowPaddingX_ = 3.0f;
static constexpr float kWindowPaddingY_ = 2.0f;
ImGui::SetNextWindowPos(
ImVec2 {
static_cast<float>(params.width),
static_cast<float>(params.height - colorTableMargins.bottom())},
ImGuiCond_Always,
ImVec2 {1.0f, 1.0f});
ImGui::SetNextWindowBgAlpha(kWindowBgAlpha_);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding,
ImVec2 {kWindowPaddingX_, kWindowPaddingY_});
ImGui::PushFont(attributionFont.first->font(),
attributionFont.second.value());
ImGui::Begin("Attribution",
@ -550,17 +654,6 @@ void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
ImGui::PopFont();
ImGui::PopStyleVar();
}
p->firstRender_ = false;
p->lastWidth_ = params.width;
p->lastHeight_ = params.height;
p->lastBearing_ = params.bearing;
p->lastFontSize_ = ImGui::GetFontSize();
p->lastColorTableMargins_ = colorTableMargins;
ImGuiFrameEnd();
SCWX_GL_CHECK_ERROR();
}
void OverlayLayer::Deinitialize()

127
scwx-qt/source/scwx/qt/map/radar_product_layer.cpp
View file

@ -63,6 +63,9 @@ public:
bool colorTableNeedsUpdate_ {false};
bool sweepNeedsUpdate_ {false};
types::RadarProductLoadStatus latchedLoadStatus_ {
types::RadarProductLoadStatus::ProductNotAvailable};
};
RadarProductLayer::RadarProductLayer(std::shared_ptr<gl::GlContext> glContext) :
@ -146,6 +149,26 @@ void RadarProductLayer::Initialize(
&view::RadarProductView::SweepComputed,
this,
[this]() { p->sweepNeedsUpdate_ = true; });
connect(radarProductView.get(),
&view::RadarProductView::SweepNotComputed,
this,
[this](types::NoUpdateReason reason)
{
if (reason == types::NoUpdateReason::NotAvailable)
{
// Ensure the radar product is hidden by re-rendering
Q_EMIT NeedsRendering();
}
if (reason == types::NoUpdateReason::NoChange)
{
if (p->latchedLoadStatus_ ==
types::RadarProductLoadStatus::ProductNotAvailable)
{
// Ensure the radar product is shown by re-rendering
Q_EMIT NeedsRendering();
}
}
});
}
void RadarProductLayer::UpdateSweep(
@ -189,10 +212,10 @@ void RadarProductLayer::UpdateSweep(
glEnableVertexAttribArray(0);
// Buffer data moments
const GLvoid* data;
GLsizeiptr dataSize;
size_t componentSize;
GLenum type;
const GLvoid* data {};
GLsizeiptr dataSize {};
size_t componentSize {};
GLenum type {};
std::tie(data, dataSize, componentSize) = radarProductView->GetMomentData();
@ -215,10 +238,10 @@ void RadarProductLayer::UpdateSweep(
glEnableVertexAttribArray(1);
// Buffer CFP data
const GLvoid* cfpData;
GLsizeiptr cfpDataSize;
size_t cfpComponentSize;
GLenum cfpType;
const GLvoid* cfpData {};
GLsizeiptr cfpDataSize {};
size_t cfpComponentSize {};
GLenum cfpType {};
std::tie(cfpData, cfpDataSize, cfpComponentSize) =
radarProductView->GetCfpMomentData();
@ -258,7 +281,6 @@ void RadarProductLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
p->shaderProgram_->Use();
// Set OpenGL blend mode for transparency
@ -281,34 +303,65 @@ void RadarProductLayer::Render(
UpdateSweep(mapContext);
}
const float scale = std::pow(2.0, params.zoom) * 2.0f *
mbgl::util::tileSize_D / mbgl::util::DEGREES_MAX;
const float xScale = scale / params.width;
const float yScale = scale / params.height;
const std::shared_ptr<view::RadarProductView> radarProductView =
mapContext->radar_product_view();
glm::mat4 uMVPMatrix(1.0f);
uMVPMatrix = glm::scale(uMVPMatrix, glm::vec3(xScale, yScale, 1.0f));
uMVPMatrix = glm::rotate(uMVPMatrix,
glm::radians<float>(params.bearing),
glm::vec3(0.0f, 0.0f, 1.0f));
bool sweepVisible = false;
types::RadarProductLoadStatus newLoadStatus =
types::RadarProductLoadStatus::ProductNotLoaded;
glUniform2fv(p->uMapScreenCoordLocation_,
1,
glm::value_ptr(util::maplibre::LatLongToScreenCoordinate(
{params.latitude, params.longitude})));
if (radarProductView != nullptr)
{
newLoadStatus = radarProductView->load_status();
glUniformMatrix4fv(
p->uMVPMatrixLocation_, 1, GL_FALSE, glm::value_ptr(uMVPMatrix));
switch (newLoadStatus)
{
case types::RadarProductLoadStatus::ProductNotAvailable:
sweepVisible = false;
break;
glUniform1i(p->uCFPEnabledLocation_, p->cfpEnabled_ ? 1 : 0);
case types::RadarProductLoadStatus::ListingProducts:
sweepVisible = p->latchedLoadStatus_ !=
types::RadarProductLoadStatus::ProductNotAvailable;
break;
glUniform1ui(p->uDataMomentOffsetLocation_, p->rangeMin_);
glUniform1f(p->uDataMomentScaleLocation_, p->scale_);
default:
sweepVisible = true;
}
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, p->texture_);
glBindVertexArray(p->vao_);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(p->numVertices_));
if (sweepVisible)
{
const double scale = std::pow(2.0, params.zoom) * 2.0 *
mbgl::util::tileSize_D / mbgl::util::DEGREES_MAX;
const auto xScale = static_cast<float>(scale / params.width);
const auto yScale = static_cast<float>(scale / params.height);
glm::mat4 uMVPMatrix(1.0f);
uMVPMatrix = glm::scale(uMVPMatrix, glm::vec3(xScale, yScale, 1.0f));
uMVPMatrix = glm::rotate(uMVPMatrix,
glm::radians(static_cast<float>(params.bearing)),
glm::vec3(0.0f, 0.0f, 1.0f));
glUniform2fv(p->uMapScreenCoordLocation_,
1,
glm::value_ptr(util::maplibre::LatLongToScreenCoordinate(
{params.latitude, params.longitude})));
glUniformMatrix4fv(
p->uMVPMatrixLocation_, 1, GL_FALSE, glm::value_ptr(uMVPMatrix));
glUniform1i(p->uCFPEnabledLocation_, p->cfpEnabled_ ? 1 : 0);
glUniform1ui(p->uDataMomentOffsetLocation_, p->rangeMin_);
glUniform1f(p->uDataMomentScaleLocation_, p->scale_);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, p->texture_);
glBindVertexArray(p->vao_);
glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(p->numVertices_));
}
if (wireframeEnabled)
{
@ -316,6 +369,16 @@ void RadarProductLayer::Render(
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
if (radarProductView != nullptr &&
// Don't latch a transition from Not Available to Listing Products
!(p->latchedLoadStatus_ ==
types::RadarProductLoadStatus::ProductNotAvailable &&
newLoadStatus == types::RadarProductLoadStatus::ListingProducts))
{
// Latch last load status
p->latchedLoadStatus_ = newLoadStatus;
}
SCWX_GL_CHECK_ERROR();
}
@ -543,7 +606,7 @@ void RadarProductLayer::UpdateColorTable(
const uint16_t rangeMin = radarProductView->color_table_min();
const uint16_t rangeMax = radarProductView->color_table_max();
const float scale = rangeMax - rangeMin;
const auto scale = static_cast<float>(rangeMax - rangeMin);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_1D, p->texture_);

1
scwx-qt/source/scwx/qt/types/map_types.hpp
View file

@ -25,6 +25,7 @@ enum class NoUpdateReason
{
NoChange,
NotLoaded,
NotAvailable,
InvalidProduct,
InvalidData
};

17
scwx-qt/source/scwx/qt/types/radar_product_types.hpp Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include <cstdint>
namespace scwx::qt::types
{
enum class RadarProductLoadStatus : std::uint8_t
{
ProductNotLoaded,
ProductLoaded,
ListingProducts,
LoadingProduct,
ProductNotAvailable
};
}

4
scwx-qt/source/scwx/qt/ui/update_dialog.cpp
View file

@ -93,9 +93,9 @@ void UpdateDialog::Impl::HandleAsset(const types::gh::ReleaseAsset& asset)
#if defined(_WIN32)
# if defined(_M_AMD64)
static constexpr std::string assetSuffix = "-x64.msi";
static const std::string assetSuffix = "-x64.msi";
# else
static constexpr std::string assetSuffix = "-arm64.msi";
static const std::string assetSuffix = "-arm64.msi";
# endif
if (asset.name_.ends_with(assetSuffix))

39
scwx-qt/source/scwx/qt/view/level2_product_view.cpp
View file

@ -11,11 +11,7 @@
#include <boost/range/irange.hpp>
#include <boost/timer/timer.hpp>
namespace scwx
{
namespace qt
{
namespace view
namespace scwx::qt::view
{
static const std::string logPrefix_ = "scwx::qt::view::level2_product_view";
@ -214,6 +210,22 @@ void Level2ProductView::ConnectRadarProductManager()
Update();
}
});
connect(radar_product_manager().get(),
&manager::RadarProductManager::ProductTimesPopulated,
this,
[this](common::RadarProductGroup group,
const std::string& /* product */,
std::chrono::system_clock::time_point queryTime)
{
if (group == common::RadarProductGroup::Level2 &&
queryTime == selected_time())
{
// If the data associated with the currently selected time is
// reloaded, update the view
Update();
}
});
}
void Level2ProductView::DisconnectRadarProductManager()
@ -552,13 +564,20 @@ void Level2ProductView::ComputeSweep()
std::shared_ptr<wsr88d::rda::ElevationScan> radarData;
std::chrono::system_clock::time_point requestedTime {selected_time()};
std::tie(radarData, p->elevationCut_, p->elevationCuts_, std::ignore) =
types::RadarProductLoadStatus loadStatus {};
std::tie(
radarData, p->elevationCut_, p->elevationCuts_, std::ignore, loadStatus) =
radarProductManager->GetLevel2Data(
p->dataBlockType_, p->selectedElevation_, requestedTime);
set_load_status(loadStatus);
if (radarData == nullptr)
{
Q_EMIT SweepNotComputed(types::NoUpdateReason::NotLoaded);
Q_EMIT SweepNotComputed(
loadStatus == types::RadarProductLoadStatus::ProductNotAvailable ?
types::NoUpdateReason::NotAvailable :
types::NoUpdateReason::NotLoaded);
return;
}
if ((radarData == p->elevationScan_) &&
@ -1369,7 +1388,7 @@ Level2ProductView::GetBinLevel(const common::Coordinate& coordinate) const
auto nextRadial = radarData->find((i + 1) % numRadials);
if (nextRadial != radarData->cend())
{
nextAngle = nextRadial->second->azimuth_angle();
nextAngle = nextRadial->second->azimuth_angle();
// Level 2 angles are the center of the bins.
const units::degrees<float> deltaAngle =
@ -1564,6 +1583,4 @@ std::shared_ptr<Level2ProductView> Level2ProductView::Create(
return std::make_shared<Level2ProductView>(product, radarProductManager);
}
} // namespace view
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::view

27
scwx-qt/source/scwx/qt/view/level3_product_view.cpp
View file

@ -11,17 +11,12 @@
#include <scwx/wsr88d/rpg/radial_data_packet.hpp>
#include <limits>
#include <unordered_set>
#include <boost/range/irange.hpp>
#include <boost/timer/timer.hpp>
#include <fmt/format.h>
namespace scwx
{
namespace qt
{
namespace view
namespace scwx::qt::view
{
static const std::string logPrefix_ = "scwx::qt::view::level3_product_view";
@ -151,6 +146,22 @@ void Level3ProductView::ConnectRadarProductManager()
Update();
}
});
connect(radar_product_manager().get(),
&manager::RadarProductManager::ProductTimesPopulated,
this,
[this](common::RadarProductGroup group,
const std::string& product,
std::chrono::system_clock::time_point queryTime)
{
if (group == common::RadarProductGroup::Level3 &&
product == p->product_ && queryTime == selected_time())
{
// If the data associated with the currently selected time is
// reloaded, update the view
Update();
}
});
}
void Level3ProductView::DisconnectRadarProductManager()
@ -596,6 +607,4 @@ bool Level3ProductView::IgnoreUnits() const
return false;
}
} // namespace view
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::view

40
scwx-qt/source/scwx/qt/view/level3_radial_view.cpp
View file

@ -10,11 +10,7 @@
#include <boost/range/irange.hpp>
#include <boost/timer/timer.hpp>
namespace scwx
{
namespace qt
{
namespace view
namespace scwx::qt::view
{
static const std::string logPrefix_ = "scwx::qt::view::level3_radial_view";
@ -31,15 +27,7 @@ static constexpr std::uint32_t VALUES_PER_VERTEX = 2u;
class Level3RadialView::Impl
{
public:
explicit Impl(Level3RadialView* self) :
self_ {self},
latitude_ {},
longitude_ {},
range_ {},
vcp_ {},
sweepTime_ {}
{
}
explicit Impl(Level3RadialView* self) : self_ {self} {}
~Impl() { threadPool_.join(); };
void ComputeCoordinates(
@ -65,13 +53,13 @@ public:
bool lastShowSmoothedRangeFolding_ {false};
bool lastSmoothingEnabled_ {false};
float latitude_;
float longitude_;
float latitude_ {};
float longitude_ {};
std::optional<float> elevation_ {};
float range_;
std::uint16_t vcp_;
float range_ {};
std::uint16_t vcp_ {};
std::chrono::system_clock::time_point sweepTime_;
std::chrono::system_clock::time_point sweepTime_ {};
};
Level3RadialView::Level3RadialView(
@ -148,9 +136,12 @@ void Level3RadialView::ComputeSweep()
std::shared_ptr<wsr88d::rpg::Level3Message> message;
std::chrono::system_clock::time_point requestedTime {selected_time()};
std::chrono::system_clock::time_point foundTime;
std::tie(message, foundTime) =
types::RadarProductLoadStatus loadStatus {};
std::tie(message, foundTime, loadStatus) =
radarProductManager->GetLevel3Data(GetRadarProductName(), requestedTime);
set_load_status(loadStatus);
// If a different time was found than what was requested, update it
if (requestedTime != foundTime)
{
@ -160,7 +151,10 @@ void Level3RadialView::ComputeSweep()
if (message == nullptr)
{
logger_->debug("Level 3 data not found");
Q_EMIT SweepNotComputed(types::NoUpdateReason::NotLoaded);
Q_EMIT SweepNotComputed(
loadStatus == types::RadarProductLoadStatus::ProductNotAvailable ?
types::NoUpdateReason::NotAvailable :
types::NoUpdateReason::NotLoaded);
return;
}
@ -752,6 +746,4 @@ std::shared_ptr<Level3RadialView> Level3RadialView::Create(
return std::make_shared<Level3RadialView>(product, radarProductManager);
}
} // namespace view
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::view

20
scwx-qt/source/scwx/qt/view/level3_raster_view.cpp
View file

@ -10,11 +10,7 @@
#include <boost/timer/timer.hpp>
#include <units/angle.h>
namespace scwx
{
namespace qt
{
namespace view
namespace scwx::qt::view
{
static const std::string logPrefix_ = "scwx::qt::view::level3_raster_view";
@ -125,9 +121,12 @@ void Level3RasterView::ComputeSweep()
std::shared_ptr<wsr88d::rpg::Level3Message> message;
std::chrono::system_clock::time_point requestedTime {selected_time()};
std::chrono::system_clock::time_point foundTime;
std::tie(message, foundTime) =
types::RadarProductLoadStatus loadStatus {};
std::tie(message, foundTime, loadStatus) =
radarProductManager->GetLevel3Data(GetRadarProductName(), requestedTime);
set_load_status(loadStatus);
// If a different time was found than what was requested, update it
if (requestedTime != foundTime)
{
@ -137,7 +136,10 @@ void Level3RasterView::ComputeSweep()
if (message == nullptr)
{
logger_->debug("Level 3 data not found");
Q_EMIT SweepNotComputed(types::NoUpdateReason::NotLoaded);
Q_EMIT SweepNotComputed(
loadStatus == types::RadarProductLoadStatus::ProductNotAvailable ?
types::NoUpdateReason::NotAvailable :
types::NoUpdateReason::NotLoaded);
return;
}
@ -538,6 +540,4 @@ std::shared_ptr<Level3RasterView> Level3RasterView::Create(
return std::make_shared<Level3RasterView>(product, radarProductManager);
}
} // namespace view
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::view

28
scwx-qt/source/scwx/qt/view/overlay_product_view.cpp
View file

@ -8,11 +8,7 @@
#include <boost/asio.hpp>
#include <boost/uuid/random_generator.hpp>
namespace scwx
{
namespace qt
{
namespace view
namespace scwx::qt::view
{
static const std::string logPrefix_ = "scwx::qt::view::overlay_product_view";
@ -128,6 +124,22 @@ void OverlayProductView::Impl::ConnectRadarProductManager()
}
},
Qt::QueuedConnection);
connect(radarProductManager_.get(),
&manager::RadarProductManager::ProductTimesPopulated,
self_,
[this](common::RadarProductGroup group,
const std::string& product,
std::chrono::system_clock::time_point queryTime)
{
if (group == common::RadarProductGroup::Level3 &&
product == kNst_ && queryTime == selectedTime_)
{
// If the data associated with the currently selected time is
// reloaded, update the view
Update(product);
}
});
}
void OverlayProductView::Impl::DisconnectRadarProductManager()
@ -286,7 +298,7 @@ void OverlayProductView::Impl::Update(const std::string& product)
std::shared_ptr<wsr88d::rpg::Level3Message> message;
std::chrono::system_clock::time_point requestedTime {selectedTime_};
std::chrono::system_clock::time_point foundTime;
std::tie(message, foundTime) =
std::tie(message, foundTime, std::ignore) =
radarProductManager_->GetLevel3Data(product, requestedTime);
// If a different time was found than what was requested, update it
@ -329,6 +341,4 @@ void OverlayProductView::SetAutoUpdate(bool enabled)
p->autoUpdateEnabled_ = enabled;
}
} // namespace view
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::view

12
scwx-qt/source/scwx/qt/view/radar_product_view.cpp
View file

@ -58,6 +58,8 @@ public:
std::chrono::system_clock::time_point selectedTime_;
bool showSmoothedRangeFolding_ {false};
bool smoothingEnabled_ {false};
types::RadarProductLoadStatus loadStatus_ {
types::RadarProductLoadStatus::ProductNotLoaded};
std::shared_ptr<manager::RadarProductManager> radarProductManager_;
@ -90,6 +92,11 @@ std::optional<float> RadarProductView::elevation() const
return {};
}
types::RadarProductLoadStatus RadarProductView::load_status() const
{
return p->loadStatus_;
}
std::shared_ptr<manager::RadarProductManager>
RadarProductView::radar_product_manager() const
{
@ -126,6 +133,11 @@ std::mutex& RadarProductView::sweep_mutex()
return p->sweepMutex_;
}
void RadarProductView::set_load_status(types::RadarProductLoadStatus loadStatus)
{
p->loadStatus_ = loadStatus;
}
void RadarProductView::set_radar_product_manager(
std::shared_ptr<manager::RadarProductManager> radarProductManager)
{

13
scwx-qt/source/scwx/qt/view/radar_product_view.hpp
View file

@ -38,11 +38,12 @@ public:
[[nodiscard]] virtual std::shared_ptr<common::ColorTable>
color_table() const = 0;
[[nodiscard]] virtual const std::vector<boost::gil::rgba8_pixel_t>&
color_table_lut() const;
[[nodiscard]] virtual std::uint16_t color_table_min() const;
[[nodiscard]] virtual std::uint16_t color_table_max() const;
[[nodiscard]] virtual std::optional<float> elevation() const;
[[nodiscard]] virtual float range() const;
color_table_lut() const;
[[nodiscard]] virtual std::uint16_t color_table_min() const;
[[nodiscard]] virtual std::uint16_t color_table_max() const;
[[nodiscard]] virtual std::optional<float> elevation() const;
[[nodiscard]] types::RadarProductLoadStatus load_status() const;
[[nodiscard]] virtual float range() const;
[[nodiscard]] virtual std::chrono::system_clock::time_point
sweep_time() const;
[[nodiscard]] virtual float unit_scale() const = 0;
@ -98,6 +99,8 @@ protected:
virtual void DisconnectRadarProductManager() = 0;
virtual void UpdateColorTableLut() = 0;
void set_load_status(types::RadarProductLoadStatus loadStatus);
protected slots:
virtual void ComputeSweep();

2
test/source/scwx/provider/aws_level3_data_provider.test.cpp
View file

@ -76,7 +76,7 @@ TEST(AwsLevel3DataProvider, GetTimePointsByDate)
AwsLevel3DataProvider provider("KLSX", "N0Q");
auto timePoints = provider.GetTimePointsByDate(date);
auto timePoints = provider.GetTimePointsByDate(date, true);
EXPECT_GT(timePoints.size(), 0);
for (auto timePoint : timePoints)

4
wxdata/include/scwx/provider/aws_level2_chunks_data_provider.hpp
View file

@ -46,7 +46,9 @@ public:
std::string FindLatestKey() override;
std::chrono::system_clock::time_point FindLatestTime() override;
std::vector<std::chrono::system_clock::time_point>
GetTimePointsByDate(std::chrono::system_clock::time_point date) override;
GetTimePointsByDate(std::chrono::system_clock::time_point date,
bool update) override;
bool IsDateCached(std::chrono::system_clock::time_point date) override;
std::tuple<bool, size_t, size_t>
ListObjects(std::chrono::system_clock::time_point date) override;
std::shared_ptr<wsr88d::NexradFile>

27
wxdata/include/scwx/provider/aws_nexrad_data_provider.hpp
View file

@ -2,17 +2,12 @@
#include <scwx/provider/nexrad_data_provider.hpp>
namespace Aws
{
namespace S3
namespace Aws::S3
{
class S3Client;
} // namespace S3
} // namespace Aws
} // namespace Aws::S3
namespace scwx
{
namespace provider
namespace scwx::provider
{
/**
@ -32,20 +27,23 @@ public:
AwsNexradDataProvider(AwsNexradDataProvider&&) noexcept;
AwsNexradDataProvider& operator=(AwsNexradDataProvider&&) noexcept;
size_t cache_size() const override;
[[nodiscard]] std::size_t cache_size() const override;
std::chrono::system_clock::time_point last_modified() const override;
std::chrono::seconds update_period() const override;
[[nodiscard]] std::chrono::system_clock::time_point
last_modified() const override;
[[nodiscard]] std::chrono::seconds update_period() const override;
std::string FindKey(std::chrono::system_clock::time_point time) override;
std::string FindLatestKey() override;
std::chrono::system_clock::time_point FindLatestTime() override;
std::vector<std::chrono::system_clock::time_point>
GetTimePointsByDate(std::chrono::system_clock::time_point date) override;
GetTimePointsByDate(std::chrono::system_clock::time_point date,
bool update) override;
bool IsDateCached(std::chrono::system_clock::time_point date) override;
std::tuple<bool, size_t, size_t>
ListObjects(std::chrono::system_clock::time_point date) override;
std::shared_ptr<wsr88d::NexradFile>
LoadObjectByKey(const std::string& key) override;
LoadObjectByKey(const std::string& key) override;
std::shared_ptr<wsr88d::NexradFile>
LoadObjectByTime(std::chrono::system_clock::time_point time) override;
std::pair<size_t, size_t> Refresh() override;
@ -61,5 +59,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace provider
} // namespace scwx
} // namespace scwx::provider

29
wxdata/include/scwx/provider/nexrad_data_provider.hpp
View file

@ -7,9 +7,7 @@
#include <string>
#include <vector>
namespace scwx
{
namespace provider
namespace scwx::provider
{
class NexradDataProvider
@ -24,7 +22,7 @@ public:
NexradDataProvider(NexradDataProvider&&) noexcept;
NexradDataProvider& operator=(NexradDataProvider&&) noexcept;
virtual size_t cache_size() const = 0;
[[nodiscard]] virtual size_t cache_size() const = 0;
/**
* Gets the last modified time. This is equal to the most recent object's
@ -32,7 +30,8 @@ public:
*
* @return Last modified time
*/
virtual std::chrono::system_clock::time_point last_modified() const = 0;
[[nodiscard]] virtual std::chrono::system_clock::time_point
last_modified() const = 0;
/**
* Gets the current update period. This is equal to the difference between
@ -41,7 +40,7 @@ public:
*
* @return Update period
*/
virtual std::chrono::seconds update_period() const = 0;
[[nodiscard]] virtual std::chrono::seconds update_period() const = 0;
/**
* Finds the most recent key in the cache, no later than the time provided.
@ -116,7 +115,7 @@ public:
*
* @return NEXRAD data time point
*/
virtual std::chrono::system_clock::time_point
[[nodiscard]] virtual std::chrono::system_clock::time_point
GetTimePointByKey(const std::string& key) const = 0;
/**
@ -124,11 +123,22 @@ public:
* to the cache if required.
*
* @param date Date for which to get NEXRAD data time points
* @param update Whether or not to list and add data not present in the cache
*
* @return NEXRAD data time points
*/
virtual std::vector<std::chrono::system_clock::time_point>
GetTimePointsByDate(std::chrono::system_clock::time_point date) = 0;
GetTimePointsByDate(std::chrono::system_clock::time_point date,
bool update) = 0;
/**
* Determines if time points for the requested date are cached.
*
* @param date Date for which to query the cache
*
* @return Whether or not the requested date is cached
*/
virtual bool IsDateCached(std::chrono::system_clock::time_point date) = 0;
/**
* Requests available NEXRAD products for the current radar site, and adds
@ -148,5 +158,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace provider
} // namespace scwx
} // namespace scwx::provider

9
wxdata/source/scwx/provider/aws_level2_chunks_data_provider.cpp
View file

@ -289,11 +289,18 @@ AwsLevel2ChunksDataProvider::FindLatestTime()
std::vector<std::chrono::system_clock::time_point>
AwsLevel2ChunksDataProvider::GetTimePointsByDate(
std::chrono::system_clock::time_point /*date*/)
std::chrono::system_clock::time_point /* date */, bool /* update */)
{
return {};
}
bool AwsLevel2ChunksDataProvider::IsDateCached(
std::chrono::system_clock::time_point /* date */)
{
// No cache, default to true
return true;
}
std::chrono::system_clock::time_point
AwsLevel2ChunksDataProvider::Impl::GetScanTime(const std::string& prefix)
{

52
wxdata/source/scwx/provider/aws_nexrad_data_provider.cpp
View file

@ -15,9 +15,7 @@
#include <aws/s3/model/ListObjectsV2Request.h>
#include <fmt/chrono.h>
namespace scwx
{
namespace provider
namespace scwx::provider
{
static const std::string logPrefix_ =
@ -177,7 +175,7 @@ std::chrono::system_clock::time_point AwsNexradDataProvider::FindLatestTime()
std::vector<std::chrono::system_clock::time_point>
AwsNexradDataProvider::GetTimePointsByDate(
std::chrono::system_clock::time_point date)
std::chrono::system_clock::time_point date, bool update)
{
const auto day = std::chrono::floor<std::chrono::days>(date);
@ -188,23 +186,26 @@ AwsNexradDataProvider::GetTimePointsByDate(
std::shared_lock lock(p->objectsMutex_);
// Is the date present in the date list?
bool currentDatePresent;
bool currentDatePresent = false;
auto currentDateIterator =
std::find(p->objectDates_.cbegin(), p->objectDates_.cend(), day);
if (currentDateIterator == p->objectDates_.cend())
{
// Temporarily unlock mutex
lock.unlock();
// List objects, since the date is not present in the date list
auto [success, newObjects, totalObjects] = ListObjects(date);
if (success)
if (update)
{
p->UpdateObjectDates(date);
}
// Temporarily unlock mutex
lock.unlock();
// Re-lock mutex
lock.lock();
// List objects, since the date is not present in the date list
const auto [success, newObjects, totalObjects] = ListObjects(date);
if (success)
{
p->UpdateObjectDates(date);
}
// Re-lock mutex
lock.lock();
}
currentDatePresent = false;
}
@ -214,8 +215,8 @@ AwsNexradDataProvider::GetTimePointsByDate(
}
// Determine objects to retrieve
auto objectsBegin = p->objects_.lower_bound(day);
auto objectsEnd = p->objects_.lower_bound(day + std::chrono::days {1});
const auto objectsBegin = p->objects_.lower_bound(day);
const auto objectsEnd = p->objects_.lower_bound(day + std::chrono::days {1});
// Copy time points to destination vector
std::transform(objectsBegin,
@ -236,6 +237,20 @@ AwsNexradDataProvider::GetTimePointsByDate(
return timePoints;
}
bool AwsNexradDataProvider::IsDateCached(
std::chrono::system_clock::time_point date)
{
const auto day = std::chrono::floor<std::chrono::days>(date);
const std::shared_lock lock(p->objectsMutex_);
// Is the date present in the date list?
const auto currentDateIterator =
std::find(p->objectDates_.cbegin(), p->objectDates_.cend(), day);
return currentDateIterator != p->objectDates_.cend();
}
std::tuple<bool, size_t, size_t>
AwsNexradDataProvider::ListObjects(std::chrono::system_clock::time_point date)
{
@ -446,5 +461,4 @@ void AwsNexradDataProvider::Impl::UpdateObjectDates(
objectDates_.push_back(day);
}
} // namespace provider
} // namespace scwx
} // namespace scwx::provider