// we cannot call draw if we are already drawing

// this could create infinite loops

if (backend_ == nullptr || is_plotting_) {

return;

}

// Avoid infinite loops if the draw function calls

// "touch" for some reason

is_plotting_ = true;

// There are two different strategies

// Gnuplot backends do not rely on vertices

// because that would be very ineficient

// So we unfortunately need a different strategy

// for gnuplot

if (!backend_->consumes_gnuplot_commands()) {

send_draw_commands();

} else {

send_gnuplot_draw_commands();

}

backend_->render_data();

is_plotting_ = false;

// This mode is not implemented yet

// Send some draw commands to the backend here

// ...

// Iterate children axes

// Ask them to send their draw commands to the backend

include_comment("Setting figure properties");

run_figure_properties_command();

if (children_.empty()) {

include_comment("An empty plot");

plot_empty_plot();

} else {

include_comment("Start multiplot");

run_multiplot_command();

bool first = true;

include_comment("Window background");

if (backend_->output().empty()) {

run_window_color_command();

}

size_t index = 1;

for (auto &axes : children_) {

include_comment("Plotting axes - " + num2str(index++));

if (!first) {

include_comment(" Reset object from multiplot - " +

num2str(index - 2));

run_command(" reset");

}

axes->run_commands();

if (first) {

include_comment("Unset window background so it does repeat "

"on other subplots");

run_unset_window_color_command();

first = false;

}

}

if (children_.size() > 1) {

include_comment(

"Multiplots don't work well with the mouse in Gnuplot");

run_command("unset mouse");

}

include_comment("Finalizing the multiplot");

run_command("unset multiplot");

}

if (!quiet_mode_) {

draw();

}

try {

auto poutput = backend_->output();

auto pformat = backend_->output_format();

if (backend_->output(filename, format)) {

draw();

}

backend_->output(poutput, pformat);

return true;

} catch (...) {

return false;

}

try {

auto pout = backend_->output();

auto pformat = backend_->output_format();

if (backend_->output(filename)) {

draw();

}

backend_->output(pout, pformat);

return true;

} catch (...) {

return false;

}

// Plot something out of yrange

run_command("set yrange [0:1]");

run_command("set xrange [0:1]");

run_command("set key off");

run_command("plot 2 with lines");

color_ = c;

custom_color_ = true;

touch();

backend_->position_x(c[0]);

backend_->position_y(c[1]);

backend_->width(c[2]);

backend_->height(c[3]);

touch();

// get x_position from the backend because the user

// might have changed it manually by dragging the

// window

return backend_->position_x();

// get y_position from the backend because the user

// might have changed it manually by dragging the

// window

return backend_->position_y();

// get width from the backend because the user

// might have changed it manually by dragging the

// window

return backend_->width();

// get height from the backend because the user

// might have changed it manually by dragging the

// window

return backend_->height();

backend_->position_x(x);

backend_->position_y(y);

touch();

backend_->width(w);

backend_->height(h);

touch();

axes_handle h = std::make_shared<class axes>(this, position);

h->box(true);

return this->add_axes(h, false, true);

bool replace_if_same_position) {

auto it = std::find_if(children_.begin(), children_.end(),

[&h](const auto &child) {

return child->position() == h->position();

});

if (it != children_.end()) {

if (replace_if_same_position) {

children_.erase(it);

} else {

return *it;

}

}

if (replace_if_overlap) {

// look for overlap

auto overlap = [&h](const axes_handle &x) {

const float x_min = x->x_origin();

const float x_max = x->x_origin() + x->width();

const float hx_min = h->x_origin();

const float hx_max = h->x_origin() + h->width();

const float y_min = x->y_origin();

const float y_max = x->y_origin() + x->height();

const float hy_min = h->y_origin();

const float hy_max = h->y_origin() + h->height();

// for dimensions 0 and 1, check min and max intersection

return !(x_min > hx_max || hx_min > x_max || y_min > hy_max ||

hy_min > y_max);

};

auto overlap_it =

std::remove_if(children_.begin(), children_.end(), overlap);

children_.erase(overlap_it, children_.end());

}

children_.emplace_back(h);

current_axes_ = children_.back();

current_axes_->parent(this);

touch();

return h;

size_t cols,

size_t plot_id) {

if (plot_id >= rows * cols) {

plot_id = plot_id % (rows * cols);

}

size_t row = rows - plot_id / cols - 1;

size_t col = plot_id % cols;

constexpr size_t row_width = 1; // max(row) - min(row) + 1

constexpr size_t col_width = 1; // max(col) - min(col) + 1

const size_t min_row = row;

const size_t min_col = col;

const size_t max_row = row;

const size_t max_col = col;

float width =

axes::default_axes_position[2] /

(static_cast<float>(cols) - axes::default_subplot_inset[0] -

axes::default_subplot_inset[2]); // 1,0197

float height =

axes::default_axes_position[3] /

(static_cast<float>(rows) - axes::default_subplot_inset[1] -

axes::default_subplot_inset[3]); // 0,4738

std::array<float, 4> subplot_inset{

axes::default_subplot_inset[0] * width,

axes::default_subplot_inset[1] * height,

axes::default_subplot_inset[2] * width,

axes::default_subplot_inset[3] * height};

std::array<float, 4> outer_pos{axes::default_axes_position[0] +

min_col * width - subplot_inset[0],

axes::default_axes_position[1] +

min_row * height - subplot_inset[1],

width * col_width, height * row_width};

if (min_col == 0) {

subplot_inset[0] = axes::default_axes_position[0];

outer_pos[2] = outer_pos[0] + outer_pos[2];

outer_pos[0] = 0;

}

if (min_row == 0) {

subplot_inset[1] = axes::default_axes_position[1];

outer_pos[3] = outer_pos[1] + outer_pos[3];

outer_pos[1] = 0;

}

if (max_col == cols - 1) {

subplot_inset[2] =

std::max(0.f, 1.f - axes::default_axes_position[0] -

axes::default_axes_position[2]);

outer_pos[2] = 1 - outer_pos[0];

}

if (max_row == rows - 1) {

subplot_inset[3] =

std::max(0., 1. - axes::default_axes_position[1] -

axes::default_axes_position[3]);

outer_pos[3] = 1 - outer_pos[1];

}

std::array<float, 4> position = {

outer_pos[0] + subplot_inset[0], outer_pos[1] + subplot_inset[1],

outer_pos[2] - subplot_inset[0] - subplot_inset[2],

outer_pos[3] - subplot_inset[1] - subplot_inset[3]};

return position;

bool replace_if_same_position) {

if (rows == 1 && cols == 1 && plot_id == 0) {

return add_axes();

}

return this->add_subplot(

calculate_subplot_position(rows, cols, plot_id),

replace_if_same_position);

axes_handle ax) {

ax->position(calculate_subplot_position(rows, cols, plot_id));

auto it = std::find(children_.begin(), children_.end(), ax);

if (it == children_.end()) {

return add_axes(ax, true, false);

}

return ax;

std::initializer_list<size_t> positions,

bool replace_if_same_position) {

if (rows == 1 && cols == 1 && positions.size() == 1 &&

*positions.begin() == 1) {

return this->add_axes(true);

}

std::vector plot_ids = std::vector(positions);

size_t max_plot_id =

*std::max_element(plot_ids.begin(), plot_ids.end());

if (max_plot_id >= rows * cols) {

throw std::invalid_argument("Plot index is too large");

}

std::vector<size_t> row(plot_ids.size());

std::vector<size_t> col(plot_ids.size());

for (size_t i = 0; i < plot_ids.size(); ++i) {

row[i] = rows - plot_ids[i] / cols - 1;

col[i] = plot_ids[i] % cols;

}

const size_t min_row = *std::min_element(row.begin(), row.end());

const size_t min_col = *std::min_element(col.begin(), col.end());

const size_t max_row = *std::max_element(row.begin(), row.end());

const size_t max_col = *std::max_element(col.begin(), col.end());

const size_t row_width = max_row - min_row + 1;

const size_t col_width = max_col - min_col + 1;

float width =

axes::default_axes_position[2] /

(static_cast<float>(cols) - axes::default_subplot_inset[0] -

axes::default_subplot_inset[2]); // 1,0197

float height =

axes::default_axes_position[3] /

(static_cast<float>(rows) - axes::default_subplot_inset[1] -

axes::default_subplot_inset[3]); // 0,4738

std::array<float, 4> subplot_inset{

axes::default_subplot_inset[0] * width,

axes::default_subplot_inset[1] * height,

axes::default_subplot_inset[2] * width,

axes::default_subplot_inset[3] * height};

std::array<float, 4> outer_pos{axes::default_axes_position[0] +

min_col * width - subplot_inset[0],

axes::default_axes_position[1] +

min_row * height - subplot_inset[1],

width * col_width, height * row_width};

if (min_col == 0) {

subplot_inset[0] = axes::default_axes_position[0];

outer_pos[2] = outer_pos[0] + outer_pos[2];

outer_pos[0] = 0;

}

if (min_row == 0) {

subplot_inset[1] = axes::default_axes_position[1];

outer_pos[3] = outer_pos[1] + outer_pos[3];

outer_pos[1] = 0;

}

if (max_col == cols - 1) {

subplot_inset[2] =

std::max(0.f, 1.f - axes::default_axes_position[0] -

axes::default_axes_position[2]);

outer_pos[2] = 1 - outer_pos[0];

}

if (max_row == rows - 1) {

subplot_inset[3] =

std::max(0., 1. - axes::default_axes_position[1] -

axes::default_axes_position[3]);

outer_pos[3] = 1 - outer_pos[1];

}

std::array<float, 4> position = {

outer_pos[0] + subplot_inset[0], outer_pos[1] + subplot_inset[1],

outer_pos[2] - subplot_inset[0] - subplot_inset[2],

outer_pos[3] - subplot_inset[1] - subplot_inset[3]};

return this->add_subplot(position, replace_if_same_position);

bool replace_if_same_position) {

axes_handle h = std::make_shared<class axes>(this, position);

h->box(true);

return this->add_axes(h, true, replace_if_same_position);

tiledlayout_rows_ = rows;

tiledlayout_cols_ = cols;

current_tile_index_ = 0;

tiledlayout_flow_ = rows == 1 && cols == 1;

children_.clear();

const bool next_tile_fits =

current_tile_index_ < tiledlayout_rows_ * tiledlayout_cols_;

if (next_tile_fits || !tiledlayout_flow_) {

if (!next_tile_fits) {

current_tile_index_ -= tiledlayout_rows_ * tiledlayout_cols_;

}

axes_handle h = this->add_subplot(

tiledlayout_rows_, tiledlayout_cols_, current_tile_index_);

current_tile_index_++;

return h;

} else {

if (tiledlayout_rows_ <= tiledlayout_cols_) {

++tiledlayout_rows_;

} else {

++tiledlayout_cols_;

}

// reposition existing axes, assuming they are all independent tiles

auto f = gcf();

for (size_t j = 0; j < f->children().size(); ++j) {

auto p = calculate_subplot_position(tiledlayout_rows_,

tiledlayout_cols_, j);

f->children()[j]->position(p);

}

return nexttile();

}

axes_handle h = current_axes_;

if (!h) {

h = this->add_axes();

}

return h;

current_axes_ = current_axes;

// bring axes to front

auto it = std::find(children_.begin(), children_.end(), current_axes);

if (it != children_.end()) {

if (*it != children_.back()) {

std::swap(*it, children_.back());

touch();

}

}

run_command("reset");

run_terminal_init_command();

if (children_.empty()) {

run_command("unset border");

run_command("unset xtics");

run_command("unset ytics");

}

if (children_.empty()) {

run_window_color_command();

}

std::stringstream ss;

auto &terminal = backend_->output_format();

ss << "set terminal " + terminal;

if (terminal.empty() &&

backend::gnuplot::terminal_has_title_option(terminal)) {

std::string title;

if (number_title_) {

title += "Figure " + num2str(number_);

if (!name_.empty()) {

title += ": " + name_;

}

} else {

title = name_;

}

ss << " title \"" << escape(title) << "\"";

run_command(ss.str());

}

if (backend::gnuplot::terminal_has_size_option(terminal)) {

ss << " size " << num2str(width()) << "," << num2str(height());

}

if (backend::gnuplot::terminal_has_enhanced_option(terminal)) {

ss << " enhanced";

}

if (backend::gnuplot::terminal_has_color_option(terminal)) {

ss << " color";

}

if (backend::gnuplot::terminal_has_font_option(terminal)) {

ss << " font \"" + escape(font_) + "," +

num2str(unsigned(font_size_)) + "\"";

}

run_command(ss.str());

const auto &output = backend_->output();

if (!output.empty()) {

run_command("set output \"" + escape(output) + "\"");

}

// In gnuplot 5.5 we have the wall function to set the axes color

// with a rectangle workaround, which does not work well for 3d.

static const auto v = backend::gnuplot::gnuplot_version();

const bool has_wall_option =

v.first > 5 || (v.first == 5 && v.second >= 5);

// So we only plot the default background if it's not 3d or version is

// higher than 5.5. Otherwise, gnuplot won't be able to set the axes

// colors.

const bool three_d_is_not_a_problem =

children_.empty() || !children_[0]->is_3d() ||

children_[0]->is_3d_map() || has_wall_option;

// If the background is custom, we plot it, but

// gnuplot will not be able to plot the axes background if it's 3d and

// its version is less than 5.5. It's the user's choice then.

const bool force_background_anyway = custom_color_;

if (title_.empty()) {

if (three_d_is_not_a_problem || force_background_anyway) {

if (to_array(color::white) != color_) {

run_command("set object 1 rectangle from screen 0,0 to "

"screen 1,1 behind fillcolor rgb \"" +

to_string(color_) +

"\" fillstyle solid 1.0 noborder");

}

}

}

if (custom_color_ || children_.empty() || !children_[0]->is_3d() ||

children_[0]->is_3d_map()) {

if (to_array(color::white) != color_) {

run_command("unset object 1");

}

}

std::string cmd = "set multiplot";

if (!title_.empty()) {

cmd += " title \"{/:Bold " + escape(title_) + "}\"";

cmd += " font '" + font_ + "," +

num2str(unsigned(font_size_ * title_font_size_multiplier_)) +

"'";

cmd += " textcolor '" + to_string(title_color_) + "'";

}

run_command(cmd);

size_t index_candidate = 1;

for (const auto &[index, figure_handle] : global_figure_handles()) {

if (index_candidate != index) {

break;

}

++index_candidate;

}

register_figure_handle(index_candidate, h);

size_t index_candidate = 1;

for (const auto &[index, figure_handle] : global_figure_handles()) {

if (index_candidate != index) {

break;

}

++index_candidate;

}

figure_handle h =

std::make_shared<class figure>(index_candidate, quiet_mode);

register_figure_handle(index_candidate, h);

return h;

figure_handle h = detail::register_figure_handle(quiet_mode);

detail::set_current_figure_handle(h);

h->touch();

return h;

figure_handle h = detail::current_figure_handle();

if (!h) {

h = figure();

}

return h;

const std::vector<std::vector<double>> &Y,

const std::string &line_spec,

bool histogram_on_diagonals) {

bool p = this->quiet_mode();

this->quiet_mode(true);

// data

size_t n_rows = X.size();

size_t n_cols = Y.size();

// results

std::vector<std::vector<scatter_handle>> S(

n_rows, std::vector<scatter_handle>(n_cols, nullptr));

std::vector<histogram_handle> H(n_cols);

// get min/max to adjust axes

// adjust x-y ranges

std::vector<double> X_min(X.size());

std::vector<double> X_max(X.size());

for (size_t i = 0; i < X.size(); ++i) {

auto [xmin_it, xmax_it] =

std::minmax_element(X[i].begin(), X[i].end());

X_min[i] = *xmin_it;

X_max[i] = *xmax_it;

}

std::vector<double> Y_min(Y.size());

std::vector<double> Y_max(Y.size());

for (size_t i = 0; i < Y.size(); ++i) {

auto [ymin_it, ymax_it] =

std::minmax_element(Y[i].begin(), Y[i].end());

Y_min[i] = *ymin_it;

Y_max[i] = *ymax_it;

}

// create scatter plots and histograms

std::vector<std::vector<axes_handle>> axs(

n_rows, std::vector<axes_handle>(n_cols, nullptr));

for (size_t i = 0; i < n_rows; ++i) {

for (size_t j = 0; j < n_cols; ++j) {

axs[i][j] = this->add_subplot(n_rows, n_cols, i * n_rows + j);

if (i != j || !histogram_on_diagonals) {

scatter_handle s = axs[i][j]->scatter(X[j], Y[i]);

S[i][j] = s;

s->line_style(line_spec);

// set limits

axs[i][j]->x_axis().limits({X_min[i], X_max[i]});

axs[i][j]->y_axis().limits({Y_min[j], Y_max[j]});

} else {

histogram_handle h = axs[i][j]->hist(X[i]);

H[i] = h;

// set limits

// we let the Y axis be defined automatically because

// it is in a different range from the other Y axes

axs[i][j]->x_axis().limits({X_min[i], X_max[i]});

}

if (i != n_rows - 1) {

axs[i][j]->xticks({});

}

if (j != 0) {

axs[i][j]->yticks({});

}

if (histogram_on_diagonals) {

if (i % 2 == 0) {

if (j == 0) {

axs[i][j]->y_axis().visible(false);

} else if (j == n_cols - 1) {

axs[i][j]->y2_axis().visible(true);

}

}

if (j % 2 == 1) {

if (i == 0) {

axs[i][j]->x2_axis().visible(true);

} else if (i == n_rows - 1) {

axs[i][j]->x_axis().visible(false);

}

}

if (n_rows % 2 == 1 && i == n_rows - 1) {

if (j == 0) {

axs[i][j]->y_axis().visible(true);

} else if (j == n_cols - 1) {

axs[i][j]->y2_axis().visible(false);

}

}

}

}

}

// get limits from the histograms and use the more extreme limit

if (histogram_on_diagonals) {

std::vector<double> H_min(X.size());

std::vector<double> H_max(X.size());

for (size_t i = 0; i < X.size(); ++i) {

histogram_handle h = std::dynamic_pointer_cast<histogram>(

*axs[0][0]->children().begin());

H_min[i] = *h->bin_edges().begin();

H_max[i] = *std::prev(h->bin_edges().end());

}

for (size_t i = 0; i < axs.size(); ++i) {

for (size_t j = 0; j < axs.size(); ++j) {

axs[i][j]->x_axis().limits({std::min(X_min[j], H_min[j]),

std::max(X_max[j], H_max[j])});

}

}

}

// compact subplots

float l_margin = axs[0][0]->x_origin();

float r_margin =

1.f - axs[0][n_cols - 1]->y_origin() - axs[0][n_cols - 1]->width();

float b_margin = axs[n_rows - 1][0]->y_origin();

float t_margin = 1.f - axs[0][0]->y_origin() - axs[0][0]->height();

float subplot_width = (1.f - l_margin - r_margin) / n_cols;

float subplot_height = (1.f - t_margin - b_margin) / n_rows;

for (size_t i = 0; i < n_rows; ++i) {

for (size_t j = 0; j < n_cols; ++j) {

axs[i][j]->width(subplot_width - 0.01);

axs[i][j]->height(subplot_height - 0.01);

axs[i][j]->x_origin(l_margin + subplot_width * j);

axs[i][j]->y_origin(1.f - t_margin - subplot_height -

subplot_height * i);

}

}

this->quiet_mode(p);

if (!p) {

this->draw();

}

return std::make_tuple(S, H, axs);