ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

双缓冲先加上

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-11 17:48:32 +08:00
parent 542637ede4
commit 0327d71536
31 changed files with 1605 additions and 2248 deletions
Download Patch File Download Diff File Expand all files Collapse all files
web_server/app/Gallery_Plot_Session.cpp
+104 -154
View File
@@ -457,22 +457,12 @@ public:
spectrum_->clear_marker_selection();
return "Marker 选择已清除";
}
if (request.id == "rebind_axes") {
spectrum_->set_frequency_axis(spectrum_->frequency_axis());
spectrum_->set_power_axis(spectrum_->power_axis());
return "Spectrum 的 shared_ptr 轴已回读并重新绑定";
}
}
if (selection_) {
if (request.id == "clear_selection") {
selection_->clear_selected_regions();
return "框选区域已清空";
}
if (request.id == "rebind_selection_axes") {
selection_->set_horizontal_axis(numeric_domain_axis_);
selection_->set_vertical_axis(value_axis_);
return "Selection Overlay 的两根轴已重新绑定";
}
}
if (waterfall_) {
if (request.id == "append_row") {
@@ -481,40 +471,22 @@ public:
}
if (request.id == "append_tick_row") {
const int tick = time_axis_->append_time(current_time_of_day());
waterfall_->append_row(tick, spectrum_values(waterfall_->frequency_bin_count(),
waterfall_->power_range()));
waterfall_->append_row(tick, spectrum_values(waterfall_->get<&Waterfall::Properties::frequency_bin_count>(),
waterfall_->get<&Waterfall::Properties::power_range>()));
return "Waterfall 已通过 int tick 重载追加一行";
}
if (request.id == "rebind_axes") {
last_action_result_ = waterfall_->frequency_axis() && waterfall_->time_axis()
? "frequency_axis/time_axis valid"
: "axis invalid";
return "Waterfall 轴绑定已回读";
}
}
if (afterglow_) {
if (request.id == "append_spectrum") {
push_afterglow_spectrum();
return "Afterglow 频谱已手动追加";
}
if (request.id == "rebind_axes") {
last_action_result_ = afterglow_->frequency_axis() && afterglow_->power_axis()
? "frequency_axis/power_axis valid"
: "axis invalid";
return "Afterglow 轴绑定已回读";
}
}
if (sweep_) {
if (request.id == "append_block") {
push_sweep_block();
return "Sweep_Spectrum 扫频块已手动追加";
}
if (request.id == "rebind_axes") {
last_action_result_ = sweep_->frequency_axis() && sweep_->power_axis()
? "frequency_axis/power_axis valid"
: "axis invalid";
return "Sweep_Spectrum 轴绑定已回读";
}
}
if (trace_) {
if (request.id == "append_sample") {
@@ -526,12 +498,6 @@ public:
trace_->append_sample(tick, std::sin(frame_index_ * 0.12));
return "Frequency_Trace 已通过 int tick 重载追加样本";
}
if (request.id == "read_axes") {
last_action_result_ = trace_->time_axis() && trace_->value_axis()
? "time_axis/value_axis valid"
: "axis invalid";
return "Frequency_Trace 轴绑定已回读";
}
}
if (constellation_) {
if (request.id == "append_points") {
@@ -542,12 +508,6 @@ public:
constellation_->fit_square_to_axes();
return "Constellation 已按轴拟合正方形";
}
if (request.id == "read_axes") {
last_action_result_ = constellation_->i_axis() && constellation_->q_axis()
? "i_axis/q_axis valid"
: "axis invalid";
return "Constellation 轴绑定已回读";
}
}
recognized = false;
return {};
@@ -764,7 +724,7 @@ public:
telemetry["spectrum"] = {
{"selectable_line_markers", spectrum_->selectable_line_marker_count()},
{"selected_marker_index", spectrum_->selected_marker_index()},
{"configured_frequency_points", spectrum_->frequency_point_size()},
{"configured_frequency_points", spectrum_->get<&Spectrum::Properties::frequency_point_size>()},
{"input_sample_count", spectrum_->sample_count()},
{"rendered_point_count", spectrum_->rendered_point_count()}
};
@@ -777,7 +737,7 @@ public:
telemetry["selection_regions"] = selection_->selected_regions().size();
if (waterfall_) {
telemetry["waterfall"] = {
{"configured_frequency_bins", waterfall_->frequency_bin_count()},
{"configured_frequency_bins", waterfall_->get<&Waterfall::Properties::frequency_bin_count>()},
{"row_count", waterfall_->row_count()},
{"stored_point_count", waterfall_->stored_point_count()},
{"rendered_cell_count", waterfall_->rendered_cell_count()},
@@ -786,8 +746,8 @@ public:
}
if (afterglow_) {
telemetry["afterglow"] = {
{"configured_frequency_points", afterglow_->frequency_point_size()},
{"configured_power_points", afterglow_->power_point_size()},
{"configured_frequency_points", afterglow_->get<&Afterglow::Properties::frequency_point_size>()},
{"configured_power_points", afterglow_->get<&Afterglow::Properties::power_point_size>()},
{"history_frame_count", afterglow_->history_count()},
{"latest_input_point_count", afterglow_->latest_spectrum_point_count()},
{"rendered_cell_count", afterglow_->rendered_cell_count()}
@@ -795,8 +755,8 @@ public:
}
if (sweep_) {
telemetry["sweep_spectrum"] = {
{"configured_bins_per_block", sweep_->bins_per_block()},
{"configured_block_count", sweep_->block_count()},
{"configured_bins_per_block", sweep_->get<&Sweep_Spectrum::Properties::bins_per_block>()},
{"configured_block_count", sweep_->get<&Sweep_Spectrum::Properties::block_count>()},
{"stored_block_count", sweep_->stored_block_count()},
{"stored_point_count", sweep_->stored_point_count()},
{"rendered_point_count", sweep_->rendered_point_count()}
@@ -819,7 +779,7 @@ public:
"rendered_point_count", constellation_->point_count() +
static_cast<std::size_t>(anchor_count)
},
{"point_lifetime_ms", constellation_->point_lifetime_ms()}
{"point_lifetime_ms", constellation_->get<&Constellation_Diagram::Properties::point_lifetime_ms>()}
};
}
if (case_id_ == "axis_lab") {
@@ -1158,102 +1118,94 @@ private:
return;
}
if (case_id_ == "spectrum" || case_id_ == "selection_overlay") {
spectrum_ = Spectrum::Builder(data_node_,
std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_),
value_axis_)
.set_frequency_range({
spectrum_ = Spectrum::Builder{}
.set<&Spectrum::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
})
.set_frequency_point_size(integer_value(state_, "frequency_point_size"))
.set_center_frequency(number_value(state_, "center_frequency"))
.set_sweep_frequency_range({
.set<&Spectrum::Properties::frequency_point_size>(integer_value(state_, "frequency_point_size"))
.set<&Spectrum::Properties::center_frequency>(number_value(state_, "center_frequency"))
.set<&Spectrum::Properties::sweep_frequency_range>(Range{
number_value(state_, "sweep_origin"),
number_value(state_, "sweep_target")
})
.build();
.build(data_node_, std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_), value_axis_);
primary_ = spectrum_;
if (case_id_ == "selection_overlay") {
selection_ = Selection_Rectangle_Overlay::Builder(
overlay_node_, numeric_domain_axis_, value_axis_)
.build();
selection_ = Selection_Rectangle_Overlay::Builder{}.build(overlay_node_, numeric_domain_axis_, value_axis_);
primary_ = selection_;
}
return;
}
if (case_id_ == "waterfall") {
waterfall_ = Waterfall::Builder(data_node_,
std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_),
time_axis_)
.set_frequency_range({
waterfall_ = Waterfall::Builder{}
.set<&Waterfall::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
})
.set_power_range({
.set<&Waterfall::Properties::power_range>(Range{
number_value(state_, "power_origin"),
number_value(state_, "power_target")
})
.set_frequency_bin_count(integer_value(state_, "frequency_bin_count"))
.set_color_map(gallery_color_map(string_value(state_, "color_map")))
.build();
.set<&Waterfall::Properties::frequency_bin_count>(integer_value(state_, "frequency_bin_count"))
.set<&Waterfall::Properties::color_map>(gallery_color_map(string_value(state_, "color_map")))
.build(data_node_, std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_), time_axis_);
primary_ = waterfall_;
return;
}
if (case_id_ == "afterglow") {
afterglow_ = Afterglow::Builder(data_node_,
std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_),
value_axis_)
.set_frequency_range({
afterglow_ = Afterglow::Builder{}
.set<&Afterglow::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
})
.set_power_range({
.set<&Afterglow::Properties::power_range>(Range{
number_value(state_, "power_origin"),
number_value(state_, "power_target")
})
.set_frequency_bin_count(integer_value(state_, "frequency_point_size"))
.set_power_bin_count(integer_value(state_, "power_point_size"))
.set_color_map(gallery_color_map(string_value(state_, "color_map")))
.build();
.set<&Afterglow::Properties::frequency_point_size>(integer_value(state_, "frequency_point_size"))
.set<&Afterglow::Properties::power_point_size>(integer_value(state_, "power_point_size"))
.set<&Afterglow::Properties::color_map>(gallery_color_map(string_value(state_, "color_map")))
.build(data_node_, std::static_pointer_cast<Frequency_Axis>(numeric_domain_axis_), value_axis_);
primary_ = afterglow_;
return;
}
if (case_id_ == "sweep_spectrum") {
sweep_ = Sweep_Spectrum::Builder(data_node_, numeric_domain_axis_, value_axis_)
.set_frequency_range({
sweep_ = Sweep_Spectrum::Builder{}
.set<&Sweep_Spectrum::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
})
.set_bins_per_block(integer_value(state_, "bins_per_block"))
.set_block_num(integer_value(state_, "block_count"))
.build();
.set<&Sweep_Spectrum::Properties::bins_per_block>(integer_value(state_, "bins_per_block"))
.set<&Sweep_Spectrum::Properties::block_count>(integer_value(state_, "block_count"))
.build(data_node_, numeric_domain_axis_, value_axis_);
primary_ = sweep_;
return;
}
if (case_id_ == "frequency_trace") {
trace_ = Frequency_Trace::Builder(data_node_, time_axis_, value_axis_)
.set_pen({
trace_ = Frequency_Trace::Builder{}
.set<&Frequency_Trace::Properties::pen>(Pen{
color_from_hex(string_value(state_, "trace_pen")),
number_value(state_, "trace_pen_width"), Line_Style::Solid,
Line_Cap::Round, Line_Join::Round
})
.build();
.build(data_node_, time_axis_, value_axis_);
primary_ = trace_;
return;
}
if (case_id_ == "constellation") {
constellation_ = Constellation_Diagram::Builder(data_node_, numeric_domain_axis_, value_axis_)
.set_i_range({
constellation_ = Constellation_Diagram::Builder{}
.set<&Constellation_Diagram::Properties::i_range>(Range{
number_value(state_, "i_origin"),
number_value(state_, "i_target")
})
.set_q_range({
.set<&Constellation_Diagram::Properties::q_range>(Range{
number_value(state_, "q_origin"),
number_value(state_, "q_target")
})
.set_type(constellation_mode(string_value(state_, "constellation_type")))
.set_phase_offset_radians(number_value(state_, "phase_offset"))
.build();
.set<&Constellation_Diagram::Properties::type>(constellation_mode(string_value(state_, "constellation_type")))
.set<&Constellation_Diagram::Properties::phase_offset_radians>(number_value(state_, "phase_offset"))
.build(data_node_, numeric_domain_axis_, value_axis_);
primary_ = constellation_;
}
}
@@ -1366,103 +1318,101 @@ private:
}
void apply_specific_state() {
if (spectrum_) {
spectrum_->set_frequency_point_size(integer_value(state_, "frequency_point_size"));
spectrum_->set_frequency_range({
spectrum_->set<&Spectrum::Properties::frequency_point_size>(integer_value(state_, "frequency_point_size"));
spectrum_->set<&Spectrum::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
});
spectrum_->set_center_frequency(number_value(state_, "center_frequency"));
spectrum_->set_sweep_frequency_range({
spectrum_->set<&Spectrum::Properties::center_frequency>(number_value(state_, "center_frequency"));
spectrum_->set<&Spectrum::Properties::sweep_frequency_range>(Range{
number_value(state_, "sweep_origin"),
number_value(state_, "sweep_target")
});
spectrum_->set_max_hold_visible(bool_value(state_, "max_hold_visible"));
spectrum_->set_min_hold_visible(bool_value(state_, "min_hold_visible"));
spectrum_->set_max_marker_visible(bool_value(state_, "max_marker_visible"));
spectrum_->set_use_min_marker(bool_value(state_, "use_min_marker"));
spectrum_->set_sweep_region_visible(bool_value(state_, "sweep_region_visible"));
spectrum_->set_visible_range_only(bool_value(state_, "visible_range_only"));
spectrum_->set_interpolation_mode(line_mode(string_value(state_, "line_interpolation")));
spectrum_->set_max_brush({color_from_hex(string_value(state_, "max_brush"), 76), Brush_Style::Solid});
spectrum_->set_current_brush({color_from_hex(string_value(state_, "current_brush"), 76), Brush_Style::Solid});
spectrum_->set_min_brush({color_from_hex(string_value(state_, "min_brush"), 76), Brush_Style::Solid});
spectrum_->set_max_pen({color_from_hex(string_value(state_, "max_pen")), 1.2});
spectrum_->set_current_pen({
spectrum_->set<&Spectrum::Properties::max_hold_visible>(bool_value(state_, "max_hold_visible"));
spectrum_->set<&Spectrum::Properties::min_hold_visible>(bool_value(state_, "min_hold_visible"));
spectrum_->set<&Spectrum::Properties::max_marker_visible>(bool_value(state_, "max_marker_visible"));
spectrum_->set<&Spectrum::Properties::use_min_marker>(bool_value(state_, "use_min_marker"));
spectrum_->set<&Spectrum::Properties::sweep_region_visible>(bool_value(state_, "sweep_region_visible"));
spectrum_->set<&Spectrum::Properties::visible_range_only>(bool_value(state_, "visible_range_only"));
spectrum_->set<&Spectrum::Properties::interpolation_mode>(line_mode(string_value(state_, "line_interpolation")));
spectrum_->set<&Spectrum::Properties::max_brush>(Brush{color_from_hex(string_value(state_, "max_brush"), 76), Brush_Style::Solid});
spectrum_->set<&Spectrum::Properties::current_brush>(Brush{color_from_hex(string_value(state_, "current_brush"), 76), Brush_Style::Solid});
spectrum_->set<&Spectrum::Properties::min_brush>(Brush{color_from_hex(string_value(state_, "min_brush"), 76), Brush_Style::Solid});
spectrum_->set<&Spectrum::Properties::max_pen>(Pen{color_from_hex(string_value(state_, "max_pen")), 1.2});
spectrum_->set<&Spectrum::Properties::current_pen>(Pen{
color_from_hex(string_value(state_, "current_pen")), 2.0,
Line_Style::Solid, Line_Cap::Round, Line_Join::Round
});
spectrum_->set_min_pen({color_from_hex(string_value(state_, "min_pen")), 1.2});
spectrum_->set_selected_marker_pen({color_from_hex(string_value(state_, "selected_marker_pen")), 2.0});
spectrum_->set_marker_pen({color_from_hex(string_value(state_, "marker_pen")), 1.2});
spectrum_->set_middle_frequency_pen({
spectrum_->set<&Spectrum::Properties::min_pen>(Pen{color_from_hex(string_value(state_, "min_pen")), 1.2});
spectrum_->set<&Spectrum::Properties::selected_marker_pen>(Pen{color_from_hex(string_value(state_, "selected_marker_pen")), 2.0});
spectrum_->set<&Spectrum::Properties::marker_pen>(Pen{color_from_hex(string_value(state_, "marker_pen")), 1.2});
spectrum_->set<&Spectrum::Properties::middle_frequency_pen>(Pen{
color_from_hex(string_value(state_, "middle_frequency_pen")),
1.0, Line_Style::Dash
});
spectrum_->set_sweep_region_brush({
spectrum_->set<&Spectrum::Properties::sweep_region_brush>(Brush{
color_from_hex(string_value(state_, "sweep_region_brush"), 80),
Brush_Style::Solid
});
spectrum_->set_use_hover_info(bool_value(state_, "hover_enabled"));
spectrum_->set_hover_tooltip_font({number_value(state_, "hover_font_size"), 500, false});
spectrum_->set_tooltip_text_pen({color_from_hex(string_value(state_, "hover_text_color"))});
spectrum_->set_hover_tooltip_background_brush(
{color_from_hex(string_value(state_, "hover_background"), 230), Brush_Style::Solid});
spectrum_->set<&Spectrum::Properties::tooltip_enabled>(bool_value(state_, "hover_enabled"));
spectrum_->set<&Spectrum::Properties::tooltip_font>(Font{number_value(state_, "hover_font_size"), 500, false});
spectrum_->set<&Spectrum::Properties::tooltip_text_pen>(Pen{color_from_hex(string_value(state_, "hover_text_color"))});
spectrum_->set<&Spectrum::Properties::tooltip_background_brush>(Brush{color_from_hex(string_value(state_, "hover_background"), 230), Brush_Style::Solid});
}
if (selection_) {
selection_->set_label_font({number_value(state_, "selection_font_size"), 500, false});
selection_->set_label_pen({color_from_hex(string_value(state_, "selection_label_pen"))});
selection_->set_selection_brush({
selection_->set<&Selection_Rectangle_Overlay::Properties::label_font>(Font{number_value(state_, "selection_font_size"), 500, false});
selection_->set<&Selection_Rectangle_Overlay::Properties::label_pen>(Pen{color_from_hex(string_value(state_, "selection_label_pen"))});
selection_->set<&Selection_Rectangle_Overlay::Properties::selection_brush>(Brush{
color_from_hex(string_value(state_, "selection_brush"), 70),
Brush_Style::Solid
});
selection_->set_selection_border_pen({
selection_->set<&Selection_Rectangle_Overlay::Properties::selection_border_pen>(Pen{
color_from_hex(string_value(state_, "selection_border")),
1.0, Line_Style::Dash
});
}
if (waterfall_) {
waterfall_->set_frequency_range({
waterfall_->set<&Waterfall::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
});
waterfall_->set_power_range({
waterfall_->set<&Waterfall::Properties::power_range>(Range{
number_value(state_, "power_origin"),
number_value(state_, "power_target")
});
waterfall_->set_frequency_bin_count(integer_value(state_, "frequency_bin_count"));
waterfall_->set_visible_range_only(bool_value(state_, "visible_range_only"));
waterfall_->set_interpolation_mode(image_mode(string_value(state_, "image_interpolation")));
waterfall_->set_use_hover_info(bool_value(state_, "hover_enabled"));
waterfall_->set_hover_tooltip_font({number_value(state_, "hover_font_size"), 500, false});
waterfall_->set_tooltip_text_pen({color_from_hex(string_value(state_, "hover_text_color"))});
waterfall_->set_hover_tooltip_background_brush(
{color_from_hex(string_value(state_, "hover_background"), 230), Brush_Style::Solid});
waterfall_->set<&Waterfall::Properties::frequency_bin_count>(integer_value(state_, "frequency_bin_count"));
waterfall_->set<&Waterfall::Properties::visible_range_only>(bool_value(state_, "visible_range_only"));
waterfall_->set<&Waterfall::Properties::interpolation_mode>(image_mode(string_value(state_, "image_interpolation")));
waterfall_->set<&Waterfall::Properties::tooltip_enabled>(bool_value(state_, "hover_enabled"));
waterfall_->set<&Waterfall::Properties::tooltip_font>(Font{number_value(state_, "hover_font_size"), 500, false});
waterfall_->set<&Waterfall::Properties::tooltip_text_pen>(Pen{color_from_hex(string_value(state_, "hover_text_color"))});
waterfall_->set<&Waterfall::Properties::tooltip_background_brush>(Brush{color_from_hex(string_value(state_, "hover_background"), 230), Brush_Style::Solid});
}
if (afterglow_) {
afterglow_->set_frequency_range({
afterglow_->set<&Afterglow::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
});
afterglow_->set_power_range({
afterglow_->set<&Afterglow::Properties::power_range>(Range{
number_value(state_, "power_origin"),
number_value(state_, "power_target")
});
afterglow_->set_frequency_point_size(integer_value(state_, "frequency_point_size"));
afterglow_->set_power_point_size(integer_value(state_, "power_point_size"));
afterglow_->set_interpolate(bool_value(state_, "interpolate_power"));
afterglow_->set_attenuation_rate(number_value(state_, "attenuation_rate"));
afterglow_->set<&Afterglow::Properties::frequency_point_size>(integer_value(state_, "frequency_point_size"));
afterglow_->set<&Afterglow::Properties::power_point_size>(integer_value(state_, "power_point_size"));
afterglow_->set<&Afterglow::Properties::interpolate>(bool_value(state_, "interpolate_power"));
afterglow_->set<&Afterglow::Properties::attenuation_rate>(number_value(state_, "attenuation_rate"));
}
if (sweep_) {
sweep_->set_frequency_range({
sweep_->set<&Sweep_Spectrum::Properties::frequency_range>(Range{
number_value(state_, "frequency_origin"),
number_value(state_, "frequency_target")
});
sweep_->set_bins_per_block(integer_value(state_, "bins_per_block"));
sweep_->set_block_count(integer_value(state_, "block_count"));
sweep_->set_pen({color_from_hex(string_value(state_, "sweep_pen")), 1.8});
sweep_->set_cur_frequency_pen({color_from_hex(string_value(state_, "current_frequency_pen")), 2.0});
sweep_->set_visible_range_only(bool_value(state_, "visible_range_only"));
sweep_->set_interpolation_mode(line_mode(string_value(state_, "line_interpolation")));
sweep_->set<&Sweep_Spectrum::Properties::bins_per_block>(integer_value(state_, "bins_per_block"));
sweep_->set<&Sweep_Spectrum::Properties::block_count>(integer_value(state_, "block_count"));
sweep_->set<&Sweep_Spectrum::Properties::pen>(Pen{color_from_hex(string_value(state_, "sweep_pen")), 1.8});
sweep_->set<&Sweep_Spectrum::Properties::current_frequency_pen>(Pen{color_from_hex(string_value(state_, "current_frequency_pen")), 2.0});
sweep_->set<&Sweep_Spectrum::Properties::visible_range_only>(bool_value(state_, "visible_range_only"));
sweep_->set<&Sweep_Spectrum::Properties::interpolation_mode>(line_mode(string_value(state_, "line_interpolation")));
}
if (trace_ && value_axis_)
value_axis_->set_coord_range({
@@ -1470,11 +1420,11 @@ private:
number_value(state_, "trace_value_max")
});
if (constellation_) {
constellation_->set_i_range({number_value(state_, "i_origin"), number_value(state_, "i_target")});
constellation_->set_q_range({number_value(state_, "q_origin"), number_value(state_, "q_target")});
constellation_->set_point_color(color_from_hex(string_value(state_, "point_color")));
constellation_->set_anchor_color(color_from_hex(string_value(state_, "anchor_color")));
constellation_->set_point_lifetime_ms(integer_value(state_, "point_lifetime_ms"));
constellation_->set<&Constellation_Diagram::Properties::i_range>(Range{number_value(state_, "i_origin"), number_value(state_, "i_target")});
constellation_->set<&Constellation_Diagram::Properties::q_range>(Range{number_value(state_, "q_origin"), number_value(state_, "q_target")});
constellation_->set<&Constellation_Diagram::Properties::point_color>(color_from_hex(string_value(state_, "point_color")));
constellation_->set<&Constellation_Diagram::Properties::anchor_color>(color_from_hex(string_value(state_, "anchor_color")));
constellation_->set<&Constellation_Diagram::Properties::point_lifetime_ms>(integer_value(state_, "point_lifetime_ms"));
if (numeric_domain_axis_)
numeric_domain_axis_->set_coord_range({
number_value(state_, "i_origin"),
@@ -1505,18 +1455,18 @@ private:
return values;
}
void push_spectrum_samples() {
spectrum_->update_samples(spectrum_values(spectrum_->frequency_point_size()));
spectrum_->update_samples(spectrum_values(spectrum_->get<&Spectrum::Properties::frequency_point_size>()));
}
void push_waterfall_row() {
waterfall_->append_row(current_time_of_day(),
spectrum_values(waterfall_->frequency_bin_count(), waterfall_->power_range()));
spectrum_values(waterfall_->get<&Waterfall::Properties::frequency_bin_count>(), waterfall_->get<&Waterfall::Properties::power_range>()));
}
void push_afterglow_spectrum() {
afterglow_->append_spectrum(spectrum_values(afterglow_->frequency_point_size(),
afterglow_->power_range()));
afterglow_->append_spectrum(spectrum_values(afterglow_->get<&Afterglow::Properties::frequency_point_size>(),
afterglow_->get<&Afterglow::Properties::power_range>()));
}
void push_sweep_block() {
const int count = sweep_->bins_per_block();
const int count = sweep_->get<&Sweep_Spectrum::Properties::bins_per_block>();
std::vector<double> block(static_cast<std::size_t>(std::max(count, 1)));
for (int index = 0; index < count; ++index) {
const double x = static_cast<double>(index) / std::max(1, count - 1);