123 lines
5.6 KiB
C++
123 lines
5.6 KiB
C++
#include <utility>
|
|
#include "../Axis/Abs_Axis.h"
|
|
#include "../base/Memory.h"
|
|
#include "Sweep_Spectrum_p.h"
|
|
namespace renderive {
|
|
RENDERIVE_DEFINE_RENDERABLE_BINDING(Sweep_Spectrum, Sweep_Spectrum_Private, Sweep_Spectrum_Render_State, Sweep_Spectrum_Input_Data, "Sweep_Frequency")
|
|
std::shared_ptr<Axis> Sweep_Spectrum::frequency_axis() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::frequency_axis).lock();
|
|
}
|
|
void Sweep_Spectrum::set_frequency_axis(std::shared_ptr<Axis> value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::frequency_axis, std::weak_ptr<Axis>(value));
|
|
}
|
|
std::shared_ptr<Axis> Sweep_Spectrum::power_axis() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::power_axis).lock();
|
|
}
|
|
void Sweep_Spectrum::set_power_axis(std::shared_ptr<Axis> value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::power_axis, std::weak_ptr<Axis>(value));
|
|
}
|
|
Range Sweep_Spectrum::frequency_range() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::frequency_range);
|
|
}
|
|
void Sweep_Spectrum::set_frequency_range(Range value) {
|
|
if (value.length() == 0.0)
|
|
return;
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::frequency_range, std::move(value));
|
|
}
|
|
int Sweep_Spectrum::bins_per_block() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::bins_per_block);
|
|
}
|
|
void Sweep_Spectrum::set_bins_per_block(int value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::bins_per_block, std::max(1, value));
|
|
}
|
|
int Sweep_Spectrum::block_count() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::block_num);
|
|
}
|
|
void Sweep_Spectrum::set_block_count(int value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::block_num, std::max(1, value));
|
|
}
|
|
Pen Sweep_Spectrum::pen() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::pen);
|
|
}
|
|
void Sweep_Spectrum::set_pen(Pen value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::pen, std::move(value));
|
|
}
|
|
Pen Sweep_Spectrum::cur_frequency_pen() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::current_frequency_pen);
|
|
}
|
|
void Sweep_Spectrum::set_cur_frequency_pen(Pen value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::current_frequency_pen, std::move(value));
|
|
}
|
|
bool Sweep_Spectrum::visible_range_only() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::visible_range_only);
|
|
}
|
|
void Sweep_Spectrum::set_visible_range_only(bool value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::visible_range_only, value);
|
|
}
|
|
Line_Interpolation_Mode Sweep_Spectrum::interpolation_mode() {
|
|
return d()->edit_state_value(&Sweep_Spectrum_Render_State::interpolation_mode);
|
|
}
|
|
void Sweep_Spectrum::set_interpolation_mode(Line_Interpolation_Mode value) {
|
|
d()->set_state_value(&Sweep_Spectrum_Render_State::interpolation_mode, value);
|
|
}
|
|
void Sweep_Spectrum::append_block(std::span<const double> data) {
|
|
if (!ok())
|
|
return;
|
|
Sweep_Spectrum_Private* pd = d();
|
|
int block_frequency_point_size{};
|
|
{
|
|
Render_State_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Render_State> state(pd);
|
|
block_frequency_point_size = state->bins_per_block;
|
|
}
|
|
if (data.size() != block_frequency_point_size)
|
|
return;
|
|
Render_Input_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Input_Data> input(pd);
|
|
input->data.push(data, Sweep_Spectrum_Input_Data::Latest_Only_Count);
|
|
}
|
|
void Sweep_Spectrum::append_block(std::pmr::vector<double>&& data) {
|
|
if (!ok())
|
|
return;
|
|
Sweep_Spectrum_Private* pd = d();
|
|
int block_frequency_point_size{};
|
|
{
|
|
Render_State_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Render_State> state(pd);
|
|
block_frequency_point_size = state->bins_per_block;
|
|
}
|
|
if (data.size() != block_frequency_point_size)
|
|
return;
|
|
Render_Input_Lease<Sweep_Spectrum_Private, Sweep_Spectrum_Input_Data> input(pd);
|
|
input->data.push(std::move(data), Sweep_Spectrum_Input_Data::Latest_Only_Count);
|
|
}
|
|
Sweep_Spectrum::Builder::Builder(std::shared_ptr<Renderable> parent, std::shared_ptr<Axis> frequency_axis, std::shared_ptr<Axis> power_axis) {
|
|
ASSERT(parent, "Sweep_Frequency build error! parent == nullptr");
|
|
ASSERT(frequency_axis && power_axis, "Sweep_Frequency build error! axis == nullptr");
|
|
ASSERT(frequency_axis->attached_to_plot(), "Sweep_Frequency build error! frequency_axis->plot == nullptr");
|
|
ASSERT(frequency_axis->shares_plot_with(*power_axis), "Sweep_Frequency build error! frequency_axis->plot != power_axis->plot");
|
|
ASSERT(parent->shares_plot_with(*frequency_axis), "Sweep_Frequency build error! parent->plot != axis->plot");
|
|
ASSERT(frequency_axis->orientation() != power_axis->orientation(), "Sweep_Frequency build error! axes must be orthogonal");
|
|
this->parent = parent;
|
|
this->frequency_axis = frequency_axis;
|
|
this->power_axis = power_axis;
|
|
}
|
|
std::shared_ptr<Sweep_Spectrum> Sweep_Spectrum::Builder::build() {
|
|
auto ret = renderive::make_shared<Sweep_Spectrum>();
|
|
ret->init(parent);
|
|
Sweep_Spectrum_Private* pd = ret->d();
|
|
Sweep_Spectrum_Render_State* sc = reinterpret_cast<Sweep_Spectrum_Render_State*>(pd->state(State_Edit));
|
|
PROP_R(std::weak_ptr<Axis>, frequency_axis)
|
|
PROP_R(std::weak_ptr<Axis>, power_axis)
|
|
PROP_R(Range, frequency_range)
|
|
PROP_R(int, bins_per_block)
|
|
PROP_R(int, block_num)
|
|
PROP_R(Pen, pen)
|
|
PROP_R(Pen, current_frequency_pen)
|
|
PROP_R(bool, visible_range_only)
|
|
PROP_R(Line_Interpolation_Mode, interpolation_mode)
|
|
sc->bins_per_block = std::max(1, sc->bins_per_block);
|
|
sc->block_num = std::max(1, sc->block_num);
|
|
if (sc->frequency_range.length() == 0.0)
|
|
sc->frequency_range = {0.0, 1.0};
|
|
return ret;
|
|
}
|
|
} // namespace renderive
|