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-02 03:43:39 +08:00
parent d8e023cea7
commit 3d027967b9
109 changed files with 1699 additions and 3979 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Core/plottable/Afterglow.cpp
+46 -46
View File
@@ -34,28 +34,28 @@ void Afterglow::set_power_range(Range value) {
edit->color_scale.set_range(value);
}
int Afterglow::frequency_point_size() {
return d()->edit_state_value(&Afterglow_Render_State::frequency_point_size);
return d()->edit_state_value(&Afterglow_Render_State::frequency_bin_count);
}
int Afterglow::power_point_size() {
return d()->edit_state_value(&Afterglow_Render_State::power_point_size);
return d()->edit_state_value(&Afterglow_Render_State::power_bin_count);
}
bool Afterglow::interpolate() {
return d()->edit_state_value(&Afterglow_Render_State::interpolate);
return d()->edit_state_value(&Afterglow_Render_State::interpolate_power_bins);
}
void Afterglow::set_interpolate(bool value) {
d()->set_state_value(&Afterglow_Render_State::interpolate, value);
d()->set_state_value(&Afterglow_Render_State::interpolate_power_bins, value);
}
double Afterglow::attenuation_rate() {
return d()->edit_state_value(&Afterglow_Render_State::attenuation_rate);
return d()->edit_state_value(&Afterglow_Render_State::decay_rate);
}
void Afterglow::set_attenuation_rate(double value) {
d()->set_state_value(&Afterglow_Render_State::attenuation_rate, std::clamp(value, 0.0, 1.0));
d()->set_state_value(&Afterglow_Render_State::decay_rate, std::clamp(value, 0.0, 1.0));
}
int Afterglow::init_strong_value() {
return d()->edit_state_value(&Afterglow_Render_State::init_strong_value);
return d()->edit_state_value(&Afterglow_Render_State::initial_intensity_threshold);
}
void Afterglow::set_init_strong_value(int value) {
d()->set_state_value(&Afterglow_Render_State::init_strong_value, std::max(1, value));
d()->set_state_value(&Afterglow_Render_State::initial_intensity_threshold, std::max(1, value));
}
Color_Map Afterglow::color_map() {
return d()->edit_state_value(&Afterglow_Render_State::color_scale).color_map();
@@ -65,19 +65,19 @@ void Afterglow::set_color_map(Color_Map value) {
edit->color_scale.set_color_map(std::move(value));
}
std::shared_ptr<Color_Bar> Afterglow::color_bar() const {
return const_cast<Afterglow*>(this)->d()->color_bar_item.lock();
return const_cast<Afterglow*>(this)->d()->color_bar.lock();
}
void Afterglow::set_frequency_point_size(int t) {
Afterglow_Private* pd = d();
Render_Edit_Lease<Afterglow_Private, Afterglow_Render_State> edit(pd);
edit->frequency_point_size = std::max(1, t);
edit->power_point_size = std::max(1, edit->power_point_size);
edit->frequency_bin_count = std::max(1, t);
edit->power_bin_count = std::max(1, edit->power_bin_count);
}
void Afterglow::set_power_point_size(int t) {
Afterglow_Private* pd = d();
Render_Edit_Lease<Afterglow_Private, Afterglow_Render_State> edit(pd);
edit->frequency_point_size = std::max(1, edit->frequency_point_size);
edit->power_point_size = std::max(1, t);
edit->frequency_bin_count = std::max(1, edit->frequency_bin_count);
edit->power_bin_count = std::max(1, t);
}
Afterglow::Builder::Builder(std::shared_ptr<Renderable> parent, std::shared_ptr<Frequency_Axis> frequency_axis, std::shared_ptr<Axis> power_axis) {
init(parent, frequency_axis, power_axis);
@@ -87,65 +87,65 @@ std::shared_ptr<Afterglow> Afterglow::Builder::build() {
set(ret.get());
return ret;
}
void Afterglow::give_data(std::span<const double> power_range_data) {
void Afterglow::append_spectrum(std::span<const double> power_range_data) {
if (!ok())
return;
Afterglow_Private* pd = d();
int frequency_point_size{};
{
Render_State_Lease<Afterglow_Private, Afterglow_Render_State> state(pd);
frequency_point_size = state->frequency_point_size;
frequency_point_size = state->frequency_bin_count;
}
if (power_range_data.size() != frequency_point_size)
return;
Render_Input_Lease<Afterglow_Private, Afterglow_Input_Data> input(pd);
input->data_list.push(power_range_data, Afterglow_Input_Data::Max_Pending_Frame_Count);
input->pending_spectra.push(power_range_data, Afterglow_Input_Data::Max_Pending_Frame_Count);
}
void Afterglow::give_data(std::pmr::vector<double>&& power_range_data) {
void Afterglow::append_spectrum(std::pmr::vector<double>&& power_range_data) {
if (!ok())
return;
Afterglow_Private* pd = d();
int frequency_point_size{};
{
Render_State_Lease<Afterglow_Private, Afterglow_Render_State> state(pd);
frequency_point_size = state->frequency_point_size;
frequency_point_size = state->frequency_bin_count;
}
if (power_range_data.size() != frequency_point_size)
return;
Render_Input_Lease<Afterglow_Private, Afterglow_Input_Data> input(pd);
input->data_list.push(std::move(power_range_data), Afterglow_Input_Data::Max_Pending_Frame_Count);
input->pending_spectra.push(std::move(power_range_data), Afterglow_Input_Data::Max_Pending_Frame_Count);
}
void Afterglow_Private::push_data(std::span<const double> power_range_data, const Afterglow_Render_State* s, const Color_Scale_Snapshot& color_scale) {
if (power_range_data.size() != s->frequency_point_size ||
s->init_strong_value <= 0 ||
if (power_range_data.size() != s->frequency_bin_count ||
s->initial_intensity_threshold <= 0 ||
color_scale.range.size() == 0.0 ||
s->frequency_point_size <= 0 ||
s->power_point_size <= 0)
s->frequency_bin_count <= 0 ||
s->power_bin_count <= 0)
return;
std::pmr::vector<int> index_list(s->frequency_point_size, frame_memory_resource());
double rate = (double)s->power_point_size / color_scale.range.size();
for (int i = 0; i < s->frequency_point_size; ++i) {
std::pmr::vector<int> index_list(s->frequency_bin_count, frame_memory_resource());
double rate = (double)s->power_bin_count / color_scale.range.size();
for (int i = 0; i < s->frequency_bin_count; ++i) {
int line_index = (int)((power_range_data[i] - color_scale.range.origin) * rate);
if (line_index < 0)
line_index = 0;
if (line_index > s->power_point_size - 1)
line_index = s->power_point_size - 1;
if (line_index > s->power_bin_count - 1)
line_index = s->power_bin_count - 1;
index_list[i] = line_index;
}
if (!s->interpolate) {
for (int i = 0; i < s->frequency_point_size; ++i) {
int index = index_list[i] * s->frequency_point_size + i;
cached_power_data[index]++;
if (!s->interpolate_power_bins) {
for (int i = 0; i < s->frequency_bin_count; ++i) {
int index = index_list[i] * s->frequency_bin_count + i;
current_intensity_grid[index]++;
}
}
else {
int last_lower = -1, last_upper = -1;
for (int i = 0; i < s->frequency_point_size; ++i) {
for (int i = 0; i < s->frequency_bin_count; ++i) {
int y = index_list[i];
cached_power_data[y * s->frequency_point_size + i]++;
current_intensity_grid[y * s->frequency_bin_count + i]++;
if (y - last_upper >= 2) {
for (int cur_y = last_upper + 1; cur_y < y; ++cur_y) {
cached_power_data[cur_y * s->frequency_point_size + i]++;
current_intensity_grid[cur_y * s->frequency_bin_count + i]++;
}
last_upper = y;
last_lower = last_lower + 1;
@@ -153,7 +153,7 @@ void Afterglow_Private::push_data(std::span<const double> power_range_data, cons
}
if (last_lower - y >= 2) {
for (int cur_y = y + 1; cur_y < last_lower; ++cur_y) {
cached_power_data[cur_y * s->frequency_point_size + i]++;
current_intensity_grid[cur_y * s->frequency_bin_count + i]++;
}
last_upper = last_lower - 1;
last_lower = y;
@@ -163,17 +163,17 @@ void Afterglow_Private::push_data(std::span<const double> power_range_data, cons
last_lower = y;
}
}
cur_index++;
if (cur_index < s->init_strong_value)
current_history_index++;
if (current_history_index < s->initial_intensity_threshold)
return;
cur_index = 0;
double old_remain = s->attenuation_rate == 1.0 ? 1.0 : 1.0 - s->attenuation_rate;
double cache_remain = s->attenuation_rate / (double)s->init_strong_value;
for (int i = 0; i < cache_buffer_buffer_size; ++i) {
merged_power_data[i] = old_remain * old_cache_power_data[i] + cache_remain * cached_power_data[i];
cached_power_data[i] = 0;
current_history_index = 0;
double old_remain = s->decay_rate == 1.0 ? 1.0 : 1.0 - s->decay_rate;
double cache_remain = s->decay_rate / (double)s->initial_intensity_threshold;
for (int i = 0; i < cached_cell_count; ++i) {
merged_intensity_grid[i] = old_remain * previous_intensity_grid[i] + cache_remain * current_intensity_grid[i];
current_intensity_grid[i] = 0;
}
old_cache_power_data = merged_power_data;
cache_image_dirty = true;
previous_intensity_grid = merged_intensity_grid;
image_dirty = true;
}
} // namespace renderive