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

加blend2d 图例分开显示

Browse Source
This commit is contained in:
种太阳的热带美短
2026-07-31 06:21:10 +08:00
parent 0df7beda49
commit fe3a4a6128
75 changed files with 2191 additions and 1425 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/Memory_Data_Path_Stress.cpp
+169 -19
View File
@@ -12,6 +12,9 @@
#include "../Renderive/plot/Latency_Eager_Plot.h"
#include "../Renderive/architecture/Timeline_Stream.h"
#include "../Renderive/base/Memory.h"
#include "../Renderive/base/Frame_Memory.h"
#include "../Renderive/architecture/Frame_Raster_Context.h"
#include "../Renderive/primitive/Curve_Utils_p.h"
#include "../Renderive/plottable/Audio_Frequency.h"
#include "../Renderive/plottable/Planisphere.h"
#include "../Renderive/plottable/Waterfall.h"
@@ -76,7 +79,7 @@ void stress_data_paths() {
auto i_axis = renderive::Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(700).set_coord_range({-2.0, 2.0}).build();
auto q_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_coord_range({-2.0, 2.0}).build();
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 100.0}).set_power_range({-120.0, 0.0}).set_frequency_point_size(64).build();
auto audio = renderive::Audio_Frequency::Builder(data_node, time_axis, value_axis).set_time_point_size(32).build();
auto audio = renderive::Audio_Frequency::Builder(data_node, time_axis, value_axis).build();
auto planisphere = renderive::Planisphere::Builder(data_node, i_axis, q_axis).set_i_range({-2.0, 2.0}).set_q_range({-2.0, 2.0}).set_continue_millisecond(500).build();
plot.show();
plot.start_render(240);
@@ -95,7 +98,6 @@ void stress_data_paths() {
waterfall->set_row_update_policy(update_modes[stage]);
waterfall->set_latest_row_min_interval_ms(2);
time_axis->set_time_point_size(time_sizes[stage]);
audio->set_time_point_size(time_sizes[stage]);
process_events(100);
std::unordered_map<int, double> expected_frequency;
QTime expected_time;
@@ -121,8 +123,8 @@ void stress_data_paths() {
auto* waterfall_data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(waterfall_data->ring_buffer.col_count, frequency_sizes[stage]);
ASSERT_EQ(waterfall_data->ring_buffer.row_count, time_sizes[stage]);
ASSERT_EQ(waterfall_data->image.width(), frequency_sizes[stage]);
ASSERT_EQ(waterfall_data->image.height(), time_sizes[stage]);
ASSERT_EQ(waterfall_data->raster_cache.image.width(), 700);
ASSERT_EQ(waterfall_data->raster_cache.image.height(), time_sizes[stage]);
int row_count = waterfall_data->ring_buffer.snapshot();
int previous_tick{};
for (int row = 0; row < row_count; ++row) {
@@ -134,7 +136,7 @@ void stress_data_paths() {
EXPECT_GT(tick, previous_tick);
previous_tick = tick;
}
auto* time_data = time_axis->d();
auto* time_data = renderive::Time_Axis_Private_Access::data(time_axis.get());
ASSERT_TRUE(time_data->timeline_snapshot);
ASSERT_EQ(time_data->timeline_snapshot->time_point_size, time_sizes[stage]);
ASSERT_EQ(time_data->timeline_snapshot->times.size(), static_cast<std::size_t>(time_sizes[stage]));
@@ -149,9 +151,9 @@ void stress_data_paths() {
}
auto* audio_data = renderive::Audio_Frequency_Private_Access::data(audio.get());
ASSERT_EQ(audio_data->point_count, time_sizes[stage]);
ASSERT_EQ(audio_data->power_snapshot.size(), static_cast<std::size_t>(time_sizes[stage]));
ASSERT_EQ(audio_data->history.size(), static_cast<std::size_t>(time_sizes[stage]));
ASSERT_NE(audio_data->data_count, 0);
EXPECT_NEAR(audio_data->power_snapshot[audio_data->data_count - 1], expected_power, 0.000001);
EXPECT_NEAR(audio_data->history_value(audio_data->data_count - 1).power, expected_power, 0.000001);
auto* planisphere_data = renderive::Planisphere_Private_Access::data(planisphere.get());
ASSERT_FALSE(planisphere_data->data_list.empty());
QPointF actual_position = planisphere_data->data_list.back().pos;
@@ -197,10 +199,10 @@ TEST(Memory_Data_Path_Stress, WaterfallWritesNewestTimelineRowAtBottom) {
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(data->image.width(), 1);
ASSERT_EQ(data->image.height(), 4);
EXPECT_EQ(qRed(data->image.image().pixel(0, 0)), 10);
EXPECT_EQ(qRed(data->image.image().pixel(0, 3)), 40);
ASSERT_EQ(data->raster_cache.image.width(), 1);
ASSERT_EQ(data->raster_cache.image.height(), 4);
EXPECT_EQ(qRed(data->raster_cache.image.image().pixel(0, 0)), 10);
EXPECT_EQ(qRed(data->raster_cache.image.image().pixel(0, 3)), 40);
}
TEST(Memory_Data_Path_Stress, WaterfallWritesNewestTimelineRowAtTopWhenTimeAxisPushesToStart) {
renderive::Latency_Eager_Plot plot;
@@ -225,10 +227,10 @@ TEST(Memory_Data_Path_Stress, WaterfallWritesNewestTimelineRowAtTopWhenTimeAxisP
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(data->image.width(), 1);
ASSERT_EQ(data->image.height(), 4);
EXPECT_EQ(qRed(data->image.image().pixel(0, 0)), 40);
EXPECT_EQ(qRed(data->image.image().pixel(0, 3)), 10);
ASSERT_EQ(data->raster_cache.image.width(), 1);
ASSERT_EQ(data->raster_cache.image.height(), 4);
EXPECT_EQ(qRed(data->raster_cache.image.image().pixel(0, 0)), 40);
EXPECT_EQ(qRed(data->raster_cache.image.image().pixel(0, 3)), 10);
}
TEST(Memory_Data_Path_Stress, DirtyLocalPixelCacheRebuildsAfterInput) {
renderive::Latency_Eager_Plot plot;
@@ -248,7 +250,7 @@ TEST(Memory_Data_Path_Stress, DirtyLocalPixelCacheRebuildsAfterInput) {
process_events(80);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
ASSERT_FALSE(cache_node->cache_image.isNull());
ASSERT_FALSE(renderive::Renderable_Private_Access::cache(*cache_node).isNull());
plot.start_render(240);
for (int frame = 0; frame < 4; ++frame) {
std::pmr::vector<double> row(renderive::memory_resource(renderive::Memory_Domain::Waterfall));
@@ -259,9 +261,157 @@ TEST(Memory_Data_Path_Stress, DirtyLocalPixelCacheRebuildsAfterInput) {
process_events(100);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
ASSERT_EQ(cache_node->cache_image.width(), 1);
ASSERT_EQ(cache_node->cache_image.height(), 4);
EXPECT_EQ(qRed(cache_node->cache_image.image().pixel(0, 3)), 40);
const auto& cache = renderive::Renderable_Private_Access::cache(*cache_node);
ASSERT_EQ(cache.width(), 1);
ASSERT_EQ(cache.height(), 4);
EXPECT_EQ(qRed(cache.image().pixel(0, 3)), 40);
}
TEST(Memory_Data_Path_Stress, WaterfallPendingRowsOverwriteInSubmissionOrder) {
renderive::Waterfall_Input_Data input;
for (int tick = 0; tick < 300; ++tick) {
const double value = static_cast<double>(tick);
input.push(tick, std::span<const double>(&value, 1));
}
std::vector<int> ticks;
input.read_all([&ticks](int tick, const std::pmr::vector<double>& values) {
ticks.push_back(tick);
ASSERT_EQ(values.size(), 1u);
EXPECT_EQ(values.front(), static_cast<double>(tick));
});
ASSERT_EQ(ticks.size(), renderive::Waterfall_Input_Data::Max_Pending_Row_Count);
EXPECT_EQ(ticks.front(), 44);
EXPECT_EQ(ticks.back(), 299);
}
TEST(Memory_Data_Path_Stress, AllPendingUsesIncrementalScanlineMapping) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(8, 4);
auto data_node = plot.create_renderable_node(plot.get_root_renderable(), "Data_Renderable");
auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(8).set_coord_range({0.0, 8.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(4).build();
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 8.0}).set_power_range({0.0, 8.0}).set_frequency_point_size(8).set_row_update_policy(renderive::Waterfall_Row_Update_Policy::All_Pending).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
std::vector<double> row(8, 1.0);
waterfall->give_data(time_axis->timeline_stream()->push_time(QTime(0, 0, 0, 1)), row);
process_events(80);
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
const std::uint64_t rebuild_count = data->raster_cache.full_rebuild_count;
row.assign(8, 2.0);
waterfall->give_data(time_axis->timeline_stream()->push_time(QTime(0, 0, 0, 2)), row);
process_events(80);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
EXPECT_EQ(data->raster_cache.full_rebuild_count, rebuild_count);
EXPECT_GT(data->raster_cache.incremental_row_count, 0u);
}
TEST(Memory_Data_Path_Stress, WaterfallRasterUsesDisplayHeight) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(8, 4);
auto data_node = plot.create_renderable_node(plot.get_root_renderable(), "Data_Renderable");
auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(8).set_coord_range({0.0, 8.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(16).build();
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 8.0}).set_power_range({0.0, 8.0}).set_frequency_point_size(8).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
for (int index = 0; index < 16; ++index) {
std::vector<double> row(8, static_cast<double>(index));
waterfall->give_data(time_axis->timeline_stream()->push_time(QTime(0, 0, 0, index)), row);
}
process_events(100);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
EXPECT_EQ(data->ring_buffer.row_count, 16);
EXPECT_EQ(data->raster_cache.image.height(), 4);
}
TEST(Memory_Data_Path_Stress, RateLimitedLatestCommitsDeferredTailWithoutNewInput) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(8, 4);
auto data_node = plot.create_renderable_node(plot.get_root_renderable(), "Data_Renderable");
auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(8).set_coord_range({0.0, 8.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(4).build();
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 8.0}).set_power_range({0.0, 8.0}).set_frequency_point_size(8).set_row_update_policy(renderive::Waterfall_Row_Update_Policy::Rate_Limited_Latest).set_latest_row_min_interval_ms(100).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
std::vector<double> row(8, 1.0);
const int first_tick = time_axis->timeline_stream()->push_time(QTime(0, 0, 0, 1));
waterfall->give_data(first_tick, row);
process_events(30);
row.assign(8, 2.0);
const int deferred_tick = time_axis->timeline_stream()->push_time(QTime(0, 0, 0, 2));
waterfall->give_data(deferred_tick, row);
process_events(180);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_GT(data->ring_buffer.data_count, 0);
EXPECT_EQ(data->ring_buffer.tick(data->ring_buffer.data_count - 1), deferred_tick);
EXPECT_FALSE(data->deferred_latest.has_value());
}
TEST(Memory_Data_Path_Stress, ExplicitMonotonicCurveClipsAndReducesToPixelWidth) {
renderive::Frame_Arena arena;
std::vector<QPointF> source;
source.reserve(10000);
for (int index = 0; index < 10000; ++index)
source.emplace_back(index, index == 4500 ? 100.0 : 0.0);
const renderive::Axis_Transform_Snapshot x_transform{{4000.0, 5000.0}, 0.0, 100.0, Qt::Horizontal};
const renderive::Axis_Transform_Snapshot y_transform{{0.0, 100.0}, 100.0, -100.0, Qt::Vertical};
auto exact = renderive::Curve_Utils::create_explicit_points(source, x_transform, y_transform, true, renderive::Line_Sampling_Mode::Exact);
auto reduced = renderive::Curve_Utils::create_explicit_points(source, x_transform, y_transform, true, renderive::Line_Sampling_Mode::Preserve_Extrema);
EXPECT_LE(exact.size(), 1003u);
EXPECT_LE(reduced.size(), 404u);
EXPECT_TRUE(std::any_of(reduced.begin(), reduced.end(), [](const QPointF& point) { return point.y() == 0.0; }));
}
TEST(Memory_Data_Path_Stress, ExplicitNonMonotonicCurveClipsSegmentsAndBreaksMissingData) {
renderive::Frame_Arena arena;
const std::vector<QPointF> source{{-2.0, 0.0}, {0.5, 1.0}, {2.0, 0.0},
{std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()},
{2.0, 2.0}, {0.5, 3.0}, {-2.0, 2.0}};
const renderive::Axis_Transform_Snapshot x_transform{{0.0, 1.0}, 0.0, 100.0, Qt::Horizontal};
const renderive::Axis_Transform_Snapshot y_transform{{0.0, 4.0}, 100.0, -100.0, Qt::Vertical};
auto points = renderive::Curve_Utils::create_explicit_points(source, x_transform, y_transform, true, renderive::Line_Sampling_Mode::Preserve_Extrema);
bool saw_break = false;
for (const QPointF& point : points) {
if (!std::isfinite(point.x())) {
saw_break = true;
continue;
}
EXPECT_GE(point.x(), 0.0);
EXPECT_LE(point.x(), 100.0);
}
EXPECT_TRUE(saw_break);
}
TEST(Memory_Data_Path_Stress, FrameRasterContextPreservesBackendOrder) {
QImage image(32, 32, QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::transparent);
renderive::Frame_Raster_Context context(image);
context.qt().fillRect(QRect(0, 0, 32, 32), Qt::red);
const std::array<QPointF, 2> line{{QPointF(2.0, 16.0), QPointF(29.0, 16.0)}};
context.stroke_polyline(line, QPen(Qt::blue, 3.0, Qt::SolidLine, Qt::FlatCap));
context.qt().fillRect(QRect(0, 0, 4, 4), Qt::green);
context.finish();
EXPECT_EQ(image.pixelColor(8, 8), QColor(Qt::red));
EXPECT_GT(image.pixelColor(16, 16).blue(), 200);
EXPECT_EQ(image.pixelColor(1, 1), QColor(Qt::green));
}
TEST(Memory_Data_Path_Stress, FrameRasterContextAppliesCacheTranslation) {
QImage image(8, 8, QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::transparent);
renderive::Frame_Raster_Context context(image, QPointF(-10.0, -10.0));
const std::array<QPointF, 2> line{{QPointF(10.0, 12.0), QPointF(17.0, 12.0)}};
context.stroke_polyline(line, QPen(Qt::white, 1.0, Qt::SolidLine, Qt::FlatCap));
context.finish();
EXPECT_GT(image.pixelColor(3, 2).alpha(), 0);
EXPECT_EQ(image.pixelColor(3, 6).alpha(), 0);
}
int main(int argc, char** argv) {
qputenv("QT_QPA_PLATFORM", "offscreen");