83 lines
4.1 KiB
C++
83 lines
4.1 KiB
C++
#include "Sweep_Spectrum.h"
|
|
#include "Curve_Sampling.h"
|
|
#include "Plottable_Real_Time_Data.h"
|
|
#include "../render/Blend2D_Cache.h"
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <deque>
|
|
namespace renderive {
|
|
namespace detail {
|
|
namespace {
|
|
using Sweep_Spectrum_History = Plottable_History_Real_Time_Data<std::vector<double>, std::deque<std::vector<double>>>;
|
|
RectF axis_content_rect(const Axis_Transform& horizontal, const Axis_Transform& vertical) {
|
|
const double x1 = horizontal.coord_to_pixel(horizontal.coordinate_range.origin);
|
|
const double x2 = horizontal.coord_to_pixel(horizontal.coordinate_range.target);
|
|
const double y1 = vertical.coord_to_pixel(vertical.coordinate_range.origin);
|
|
const double y2 = vertical.coord_to_pixel(vertical.coordinate_range.target);
|
|
return {std::min(x1, x2), std::min(y1, y2), std::abs(x2 - x1), std::abs(y2 - y1)};
|
|
}
|
|
std::vector<double> flatten(const std::deque<std::vector<double>>& blocks) {
|
|
std::vector<double> values;
|
|
for(const auto& block : blocks)
|
|
values.insert(values.end(), block.begin(), block.end());
|
|
return values;
|
|
}
|
|
}
|
|
struct Sweep_Spectrum_Control::Impl {
|
|
Impl(Sweep_Spectrum_Control& owner, std::shared_ptr<Axis> frequency, std::shared_ptr<Axis> power)
|
|
: frequency_axis(std::move(frequency)), power_axis(std::move(power)), blocks(observe_real_time_data(owner)) {}
|
|
std::shared_ptr<Axis> frequency_axis;
|
|
std::shared_ptr<Axis> power_axis;
|
|
Sweep_Spectrum_History blocks;
|
|
};
|
|
Sweep_Spectrum_Control::Sweep_Spectrum_Control(Plot_Core& plot, const Sweep_Spectrum_Properties& properties, std::shared_ptr<Axis> frequency_axis, std::shared_ptr<Axis> power_axis)
|
|
: Plottable_State(plot, properties), impl_(std::make_unique<Impl>(*this, std::move(frequency_axis), std::move(power_axis))) {}
|
|
Sweep_Spectrum_Control::~Sweep_Spectrum_Control() = default;
|
|
void Sweep_Spectrum_Control::append_block(std::span<const double> values) {
|
|
if(get<&Sweep_Spectrum_Properties::bins_per_block>() <= 0)
|
|
set<&Sweep_Spectrum_Properties::bins_per_block>(static_cast<int>(values.size()));
|
|
const int limit = get<&Sweep_Spectrum_Properties::block_count>();
|
|
impl_->blocks.update({values.begin(), values.end()}, static_cast<std::size_t>(limit));
|
|
changed();
|
|
}
|
|
void Sweep_Spectrum_Control::append_block(std::pmr::vector<double>&& values) {
|
|
append_block(std::span<const double>(values.data(), values.size()));
|
|
}
|
|
std::size_t Sweep_Spectrum_Control::stored_block_count() const {
|
|
return impl_->blocks.size();
|
|
}
|
|
std::size_t Sweep_Spectrum_Control::stored_point_count() const {
|
|
const auto blocks = impl_->blocks.snapshot();
|
|
std::size_t count{};
|
|
for(const auto& block : blocks)
|
|
count += block.size();
|
|
return count;
|
|
}
|
|
std::size_t Sweep_Spectrum_Control::rendered_point_count() const {
|
|
const auto state = properties();
|
|
const auto values = flatten(impl_->blocks.snapshot());
|
|
return curve_points(values, state.frequency_range, impl_->frequency_axis->transform(), impl_->power_axis->transform(), state.visible_range_only, state.interpolation_mode).size();
|
|
}
|
|
void Sweep_Spectrum_Control::publish() {
|
|
publish_properties();
|
|
const int limit = get<&Sweep_Spectrum_Properties::block_count>();
|
|
impl_->blocks.retain_latest(static_cast<std::size_t>(limit));
|
|
}
|
|
void Sweep_Spectrum_Control::paint(Painter& painter) {
|
|
const auto state = render_properties();
|
|
const auto blocks = impl_->blocks.snapshot();
|
|
const auto values = flatten(blocks);
|
|
if(values.size() < 2)
|
|
return;
|
|
const Axis_Transform x = impl_->frequency_axis->transform();
|
|
const Axis_Transform y = impl_->power_axis->transform();
|
|
painter.polyline(curve_points(values, state.frequency_range, x, y, state.visible_range_only, state.interpolation_mode), state.pen);
|
|
const double completed = std::min(1.0, static_cast<double>(blocks.size()) / state.block_count.get());
|
|
const double frequency = state.frequency_range.origin + state.frequency_range.length() * completed;
|
|
const RectF content = axis_content_rect(x, y);
|
|
const double marker_x = x.coord_to_pixel(frequency);
|
|
painter.line({marker_x, content.y}, {marker_x, content.bottom()}, state.current_frequency_pen);
|
|
}
|
|
}
|
|
}
|