ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
996e6f615447ba402c796232ef7918f909a31043
Renderive/Core2/axis/Axis.cpp
T
psc feb7c72e94 网页升级
2026-08-11 06:21:51 +08:00

407 lines
17 KiB
C++
Raw Blame History

#include "Axis.h"
#include "../plot/Plot_Core.h"
#include "../render/Blend2D_Cache.h"
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <sstream>
namespace renderive {
namespace {
bool valid_range(Range range) {
return std::isfinite(range.origin) && std::isfinite(range.target) && range.size() > 0.0;
}
std::string fixed_number(double value, int precision) {
std::ostringstream stream;
stream << std::fixed << std::setprecision(std::clamp(precision, 0, 12)) << value;
std::string result = stream.str();
if (result.find('.') != std::string::npos) {
while (!result.empty() && result.back() == '0')
result.pop_back();
if (!result.empty() && result.back() == '.')
result.pop_back();
}
return result;
}
std::string localized_number(double value, int precision, Number_Locale locale) {
std::string result = fixed_number(value, precision);
if (locale.decimal_point != '.')
std::replace(result.begin(), result.end(), '.', locale.decimal_point);
return result;
}
std::string formatted_time(Time_Of_Day time, std::string_view format) {
const auto total = time.milliseconds;
const int hours = static_cast<int>((total / 3'600'000) % 24);
const int minutes = static_cast<int>((total / 60'000) % 60);
const int seconds = static_cast<int>((total / 1'000) % 60);
const int milliseconds = static_cast<int>(total % 1'000);
const auto digits = [](int value, int width) {
std::ostringstream stream;
stream << std::setfill('0') << std::setw(width) << value;
return stream.str();
};
std::string result;
for (std::size_t index = 0; index < format.size();) {
const std::string_view rest = format.substr(index);
if (rest.starts_with("zzz")) {
result += digits(milliseconds, 3);
index += 3;
} else if (rest.starts_with("hh") || rest.starts_with("HH")) {
result += digits(hours, 2);
index += 2;
} else if (rest.starts_with("mm")) {
result += digits(minutes, 2);
index += 2;
} else if (rest.starts_with("ss")) {
result += digits(seconds, 2);
index += 2;
} else {
result.push_back(format[index++]);
}
}
return result;
}
} // namespace
Abs_Axis::Abs_Axis(Plot_Core& plot, Orientation orientation) : Renderable(plot, true) {
axis_state_.orientation = orientation;
}
Abs_Axis::~Abs_Axis() = default;
#define RENDERIVE_AXIS_PROPERTY(Type, Name) \
Type Abs_Axis::Name() const { std::lock_guard lock(axis_mutex_); return axis_state_.Name; } \
void Abs_Axis::set_##Name(Type value) { \
{ std::lock_guard lock(axis_mutex_); if (axis_state_.Name == value) return; axis_state_.Name = std::move(value); } \
changed(); \
}
RENDERIVE_AXIS_PROPERTY(int, x)
RENDERIVE_AXIS_PROPERTY(int, y)
RENDERIVE_AXIS_PROPERTY(Orientation, orientation)
RENDERIVE_AXIS_PROPERTY(std::size_t, pixel_length)
RENDERIVE_AXIS_PROPERTY(int, tick_length)
RENDERIVE_AXIS_PROPERTY(int, sub_tick_length)
RENDERIVE_AXIS_PROPERTY(Color, color)
RENDERIVE_AXIS_PROPERTY(Number_Locale, locale)
RENDERIVE_AXIS_PROPERTY(std::string, unit_text)
RENDERIVE_AXIS_PROPERTY(Font, unit_text_font)
RENDERIVE_AXIS_PROPERTY(Pen, unit_text_pen)
RENDERIVE_AXIS_PROPERTY(Brush, unit_text_background_brush)
RENDERIVE_AXIS_PROPERTY(int, label_rotation_degrees)
#undef RENDERIVE_AXIS_PROPERTY
Abs_Axis::State Abs_Axis::axis_state() const {
std::lock_guard lock(axis_mutex_);
return axis_state_;
}
Axis_Transform Abs_Axis::transform() const {
const State state = axis_state();
return {
coord_range(),
state.orientation == Orientation::Horizontal ? static_cast<double>(state.x)
: static_cast<double>(state.y),
static_cast<double>(state.pixel_length)
};
}
double Abs_Axis::pixel_to_coord(double pixel) const { return transform().pixel_to_coord(pixel); }
double Abs_Axis::coord_to_pixel(double coordinate) const { return transform().coord_to_pixel(coordinate); }
double Abs_Axis::start_coord() const { return coord_range().origin; }
double Abs_Axis::end_coord() const { return coord_range().target; }
int Abs_Axis::pixel_sample_count(Range range) const {
const Axis_Transform value = transform();
const double first = value.coord_to_pixel(range.origin);
const double last = value.coord_to_pixel(range.target);
return std::max(0, static_cast<int>(std::abs(last - first)) + 1);
}
int Abs_Axis::pixel_sample_count() const {
return static_cast<int>(pixel_length()) + (pixel_length() > 0 ? 1 : 0);
}
double Abs_Axis::tick_step(Range range) const {
const double raw = range.size() / 5.0;
if (!(raw > 0.0) || !std::isfinite(raw))
return 1.0;
const double scale = std::pow(10.0, std::floor(std::log10(raw)));
const double normalized = raw / scale;
const double nice = normalized <= 1.0 ? 1.0 : normalized <= 2.0 ? 2.0 : normalized <= 5.0 ? 5.0 : 10.0;
return nice * scale;
}
int Abs_Axis::sub_tick_count(double) const { return 4; }
std::string Abs_Axis::tick_label(double tick) const {
return localized_number(tick, 2, locale());
}
void Abs_Axis::paint(detail::Painter& painter) {
const State state = axis_state();
if (state.pixel_length == 0)
return;
const Range coordinates = coord_range();
const double step = tick_step(coordinates);
if (!(step > 0.0))
return;
const Pen axis_pen{state.color, 1.0};
const PointF first{static_cast<double>(state.x), static_cast<double>(state.y)};
const PointF last = state.orientation == Orientation::Horizontal
? PointF{first.x + state.pixel_length, first.y}
: PointF{first.x, first.y + state.pixel_length};
painter.line(first, last, axis_pen);
const auto [low, high] = std::minmax(coordinates.origin, coordinates.target);
const double initial = std::ceil(low / step) * step;
int tick_index{};
for (double tick = initial; tick <= high + step * 1e-6 && tick_index < 1000;
tick += step, ++tick_index) {
const double pixel = coord_to_pixel(tick);
PointF tick_start;
PointF tick_end;
PointF label;
if (state.orientation == Orientation::Horizontal) {
tick_start = {pixel, static_cast<double>(state.y)};
tick_end = {pixel, static_cast<double>(state.y + state.tick_length)};
label = {pixel + 2.0, static_cast<double>(state.y + state.tick_length + 2)};
} else {
tick_start = {static_cast<double>(state.x), pixel};
tick_end = {static_cast<double>(state.x + state.tick_length), pixel};
label = {static_cast<double>(state.x + state.tick_length + 2), pixel - 7.0};
}
painter.line(tick_start, tick_end, axis_pen);
painter.text(label, tick_label(tick), state.unit_text_font, state.unit_text_pen,
state.label_rotation_degrees);
const int subdivisions = std::max(0, sub_tick_count(step));
for (int sub_index = 1; sub_index <= subdivisions; ++sub_index) {
const double sub_tick = tick + step * sub_index / (subdivisions + 1.0);
if (sub_tick >= high)
break;
const double sub_pixel = coord_to_pixel(sub_tick);
if (state.orientation == Orientation::Horizontal) {
painter.line({sub_pixel, static_cast<double>(state.y)},
{sub_pixel, static_cast<double>(state.y + state.sub_tick_length)},
axis_pen);
} else {
painter.line({static_cast<double>(state.x), sub_pixel},
{static_cast<double>(state.x + state.sub_tick_length), sub_pixel},
axis_pen);
}
}
}
if (!state.unit_text.empty()) {
const PointF position{last.x + 4.0, last.y + 4.0};
const double estimated_width = std::max(4.0, state.unit_text.size() * state.unit_text_font.size * 0.65);
painter.rect({position.x - 2.0, position.y - 2.0,
estimated_width + 4.0, state.unit_text_font.size * 1.5 + 4.0},
Pen{.style = Line_Style::None}, state.unit_text_background_brush);
painter.text(position, state.unit_text,
state.unit_text_font, state.unit_text_pen);
}
}
Axis::Axis(Plot_Core& plot, Orientation orientation) : Abs_Axis(plot, orientation) {}
Range Axis::coord_range() const { std::lock_guard lock(interaction_mutex_); return coordinates_; }
int Axis::label_precision() const { std::lock_guard lock(interaction_mutex_); return precision_; }
void Axis::set_label_precision(int value) { { std::lock_guard lock(interaction_mutex_); precision_ = std::clamp(value, 0, 12); } changed(); }
double Axis::coord_start() const { return coord_range().origin; }
void Axis::set_coord_start(double value) { auto range = coord_range(); set_coord_range({value, value + range.length()}); }
double Axis::coord_length() const { return coord_range().length(); }
void Axis::set_coord_length(double value) { auto range = coord_range(); set_coord_range({range.origin, range.origin + value}); }
void Axis::set_coord_range(Range range) {
if (!valid_range(range))
return;
{
std::lock_guard lock(interaction_mutex_);
if (coordinates_ == range)
return;
coordinates_ = range;
}
changed();
}
void Axis::set_use_wheel(bool value) { std::lock_guard lock(interaction_mutex_); wheel_enabled_ = value; }
void Axis::set_use_drag(bool value) { std::lock_guard lock(interaction_mutex_); drag_enabled_ = value; }
bool Axis::use_wheel() const { std::lock_guard lock(interaction_mutex_); return wheel_enabled_; }
bool Axis::use_drag() const { std::lock_guard lock(interaction_mutex_); return drag_enabled_; }
void Axis::handle_event(const Event& event) {
if (event.type == Event_Type::Wheel && use_wheel()) {
const auto& wheel = static_cast<const Wheel_Event&>(event);
Range range = coord_range();
const double anchor_pixel = orientation() == Orientation::Horizontal ? wheel.position.x : wheel.position.y;
const double anchor = pixel_to_coord(anchor_pixel);
const double factor = wheel.angle_delta_y >= 0.0 ? 0.9 : 1.1;
set_coord_range({anchor + (range.origin - anchor) * factor,
anchor + (range.target - anchor) * factor});
event.accept();
return;
}
if (!use_drag())
return;
if (event.type == Event_Type::Pointer_Press) {
const auto& pointer = static_cast<const Pointer_Event&>(event);
if (pointer.button == Mouse_Button::Left) {
std::lock_guard lock(interaction_mutex_);
dragging_ = true;
last_pointer_ = pointer.position;
event.accept();
}
} else if (event.type == Event_Type::Pointer_Move) {
const auto& pointer = static_cast<const Pointer_Event&>(event);
PointF previous;
{
std::lock_guard lock(interaction_mutex_);
if (!dragging_)
return;
previous = last_pointer_;
last_pointer_ = pointer.position;
}
const double delta = orientation() == Orientation::Horizontal
? pointer.position.x - previous.x
: pointer.position.y - previous.y;
Range range = coord_range();
const double shift = pixel_length() == 0 ? 0.0 : -delta * range.length() / pixel_length();
set_coord_range({range.origin + shift, range.target + shift});
event.accept();
} else if (event.type == Event_Type::Pointer_Release) {
std::lock_guard lock(interaction_mutex_);
if (dragging_) {
dragging_ = false;
event.accept();
}
}
}
std::string Axis::tick_label(double tick) const {
return localized_number(tick, label_precision(), locale());
}
Axis::Builder::Builder(std::shared_ptr<Renderable> parent, Orientation orientation)
: Axis_Builder_Base(std::move(parent), orientation) {}
std::shared_ptr<Axis> Axis::Builder::build() {
if (!parent_)
return {};
auto result = parent_->plot().make_renderable<Axis>(parent_, orientation_);
apply(*result);
result->set_coord_range(coordinates_);
result->set_label_precision(precision_);
result->set_use_wheel(wheel_);
result->set_use_drag(drag_);
return result;
}
Frequency_Axis::Frequency_Axis(Plot_Core& plot, Orientation orientation) : Axis(plot, orientation) {}
std::string Frequency_Axis::tick_label(double tick) const {
const double absolute = std::abs(tick);
if (absolute >= 1'000'000.0)
return localized_number(tick / 1'000'000.0, label_precision(), locale()) + " MHz";
if (absolute >= 1'000.0)
return localized_number(tick / 1'000.0, label_precision(), locale()) + " kHz";
return localized_number(tick, label_precision(), locale()) + " Hz";
}
Frequency_Axis::Builder::Builder(std::shared_ptr<Renderable> parent, Orientation orientation)
: Axis_Builder_Base(std::move(parent), orientation) {}
std::shared_ptr<Frequency_Axis> Frequency_Axis::Builder::build() {
if (!parent_)
return {};
auto result = parent_->plot().make_renderable<Frequency_Axis>(parent_, orientation_);
apply(*result);
result->set_coord_range(coordinates_);
result->set_label_precision(precision_);
result->set_use_wheel(wheel_);
result->set_use_drag(drag_);
return result;
}
Time_Axis::Time_Axis(Plot_Core& plot, Orientation orientation) : Abs_Axis(plot, orientation) {}
int Time_Axis::visible_time_point_count() const { std::lock_guard lock(time_mutex_); return time_state_.visible_count; }
void Time_Axis::set_visible_time_point_count(int value) { { std::lock_guard lock(time_mutex_); time_state_.visible_count = std::max(2, value); } changed(); }
int Time_Axis::tick_label_spacing_px() const { std::lock_guard lock(time_mutex_); return time_state_.tick_label_spacing_px; }
void Time_Axis::set_tick_label_spacing_px(int value) { { std::lock_guard lock(time_mutex_); time_state_.tick_label_spacing_px = std::max(0, value); } changed(); }
std::string Time_Axis::time_format() const { std::lock_guard lock(time_mutex_); return time_state_.format; }
void Time_Axis::set_time_format(std::string value) { { std::lock_guard lock(time_mutex_); time_state_.format = std::move(value); } changed(); }
Font Time_Axis::font() const { return unit_text_font(); }
void Time_Axis::set_font(Font value) { set_unit_text_font(value); }
bool Time_Axis::newest_at_axis_start() const { std::lock_guard lock(time_mutex_); return time_state_.newest_at_start; }
void Time_Axis::set_newest_at_axis_start(bool value) { { std::lock_guard lock(time_mutex_); time_state_.newest_at_start = value; } changed(); }
std::size_t Time_Axis::time_point_count() const { std::lock_guard lock(time_mutex_); return time_state_.samples.size(); }
int Time_Axis::append_time(Time_Of_Day time) {
int tick{};
{
std::lock_guard lock(time_mutex_);
tick = time_state_.next_tick++;
time_state_.samples.emplace_back(tick, time);
const auto limit = static_cast<std::size_t>(std::max(512, time_state_.visible_count * 4));
while (time_state_.samples.size() > limit)
time_state_.samples.pop_front();
}
changed();
return tick;
}
Time_Of_Day Time_Axis::tick_to_time(int tick) const {
std::lock_guard lock(time_mutex_);
auto iterator = std::find_if(time_state_.samples.begin(), time_state_.samples.end(),
[tick](const auto& value) { return value.first == tick; });
return iterator == time_state_.samples.end() ? Time_Of_Day{} : iterator->second;
}
Range Time_Axis::coord_range() const {
std::lock_guard lock(time_mutex_);
const int latest = std::max(1, time_state_.next_tick - 1);
const int earliest = std::max(0, latest - time_state_.visible_count + 1);
return time_state_.newest_at_start ? Range{static_cast<double>(latest), static_cast<double>(earliest)}
: Range{static_cast<double>(earliest), static_cast<double>(latest)};
}
double Time_Axis::tick_step(Range range) const {
const double available = static_cast<double>(pixel_length());
const double label_width = std::max(48.0, font().size * 7.0);
const double spacing = static_cast<double>(tick_label_spacing_px());
const double label_count = std::max(1.0, available / (label_width + spacing));
return std::max(1.0, std::ceil(range.size() / label_count));
}
std::string Time_Axis::tick_label(double tick) const {
const Time_Of_Day time = tick_to_time(static_cast<int>(std::llround(tick)));
if (!time.valid())
return {};
return formatted_time(time, time_format());
}
Time_Axis::Builder::Builder(std::shared_ptr<Renderable> parent, Orientation orientation)
: Axis_Builder_Base(std::move(parent), orientation) {}
std::shared_ptr<Time_Axis> Time_Axis::Builder::build() {
if (!parent_)
return {};
auto result = parent_->plot().make_renderable<Time_Axis>(parent_, orientation_);
apply(*result);
result->set_visible_time_point_count(visible_count_);
result->set_tick_label_spacing_px(spacing_);
result->set_time_format(format_);
result->set_font(font_);
result->set_newest_at_axis_start(newest_at_start_);
return result;
}
} // namespace renderive
Reference in New Issue View Git Blame Copy Permalink