p1788 0.1.0 → 1.0.0

data/ext/p1788/figure.cc

@@ -0,0 +1,1284 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of P1788. <https://gitlab.ensta-bretagne.fr/bollenth/p1788>
+ *
+ * P1788 is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * P1788 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with P1788. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+
+#include <cstdlib>
+#include <cstdio>
+#include <sstream>
+#include <limits>
+#include <math.h>
+#include <cairo/cairo-svg.h>
+#include <cairo/cairo-pdf.h>
+#include <stdexcept>
+#include "figure.hh"
+
+/* TODO
+ * graduation 0, 0.5. 1
+ */
+
+#define P1788FIGURECOMMAND_CHECK_TYPE(type, expected, valuetype) \
+	do { \
+		if (((int)type & expected) == 0 || ((int)type & ~expected) != 0) { \
+			fprintf(stderr, "badd Command(%d) for command constructor with valuetype value\n", (int)type); \
+			exit(-1); \
+		} \
+	} while (0) \
+
+typedef std::string stringclass;
+typedef std::vector<P1788Figure::Box> boxvectorclass;
+
+
+#if 0
+static const char* cmd_type_to_str(P1788Figure::Command::command_type_t t)
+{
+	const char *r = "ERROR";
+	switch (t) {
+		case P1788Figure::Command::NONE:
+			r = "NONE"; break;
+		case P1788Figure::Command::STROKE:
+			r = "STROKE bool"; break;
+		case P1788Figure::Command::FILL:
+			r = "FILL bool"; break;
+		case P1788Figure::Command::STROKE_WIDTH:
+			r = "STROKE_WIDTH float"; break;
+		case P1788Figure::Command::STROKE_COLOR:
+			r = "STROKE_COLOR unsigned int"; break;
+		case P1788Figure::Command::FILL_COLOR:
+			r = "FILL_COLOR unsigned int"; break;
+		case P1788Figure::Command::DRAW_BOXES:
+			r = "DRAW_BOXES std::vector<Box>"; break;
+		default:
+			break;
+	}
+	return r;
+}
+#endif
+
+
+P1788Figure::Command::Command(P1788Figure::Command::command_type_t type, bool v) :
+	m_type(type),
+	m_bool(v)
+{
+	P1788FIGURECOMMAND_CHECK_TYPE(type, 0x03, bool);
+}
+
+
+P1788Figure::Command::Command(P1788Figure::Command::command_type_t type, float v) :
+	m_type(type),
+	m_float(v)
+{
+	P1788FIGURECOMMAND_CHECK_TYPE(type, 0x04, float);
+}
+
+
+P1788Figure::Command::Command(P1788Figure::Command::command_type_t type, unsigned int c) :
+	m_type(type),
+	m_uint(c)
+{
+	P1788FIGURECOMMAND_CHECK_TYPE(type, 0x18, unsigned int);
+}
+
+
+P1788Figure::Command::Command(P1788Figure::Command::command_type_t type, std::vector<Box>&& v) :
+	m_type(type),
+	m_boxes(std::move(v))
+{
+	P1788FIGURECOMMAND_CHECK_TYPE(type, 0x20, std::vector<Box>);
+}
+
+
+P1788Figure::Command::Command(P1788Figure::Command::command_type_t type, const Box& b) :
+	m_type(type),
+	m_boxes()
+{
+	P1788FIGURECOMMAND_CHECK_TYPE(type, 0x20, Box);
+	m_boxes.emplace_back(b);
+}
+
+
+P1788Figure::Command::Command(P1788Figure::Command&& c) :
+	m_type(c.m_type)
+{
+//	printf("Command(Command&&) %s\n", cmd_type_to_str(m_type));
+	switch (m_type) {
+		case STROKE:
+		case FILL:
+			m_bool = c.m_bool;
+			break;
+		case STROKE_WIDTH:
+			m_float = c.m_float;
+			break;
+		case STROKE_COLOR:
+		case FILL_COLOR:
+			m_uint = c.m_uint;
+			break;
+		case DRAW_BOXES:
+			new (&m_boxes) std::vector<Box>(std::move(c.m_boxes));
+			break;
+		default:
+			break;
+	}
+}
+
+
+P1788Figure::Command::~Command()
+{
+//	printf("~Command(%s)\n", cmd_type_to_str(m_type));
+	if (m_type == DRAW_BOXES)
+		m_boxes.~boxvectorclass();
+}
+
+
+void P1788Figure::Command::push_box(const Box& b)
+{
+	if (m_type == DRAW_BOXES)
+		m_boxes.emplace_back(b);
+}
+
+
+static inline void P1788Figure_check_cairo_status(cairo_status_t s)
+{
+	if (s == CAIRO_STATUS_SUCCESS)
+		return;
+	throw std::runtime_error(cairo_status_to_string(s));
+}
+
+
+static void P1788Figure_print_boxes(P1788Figure::State& s, const std::vector<P1788Figure::Box>& boxes)
+{
+	const size_t l = boxes.size();
+	P1788Figure::Box b;
+	for (size_t i = 0; i < l; i++) {
+		s.real_box_to_screen_box(boxes[i], b);
+//		printf("[%g, %g], [%g, %g] => [%g, %g], [%g, %g]\n",
+//				Interval::inf(boxes[i].x), Interval::sup(boxes[i].x),
+//				Interval::inf(boxes[i].y), Interval::sup(boxes[i].y),
+//				Interval::inf(b.x), Interval::sup(b.x),
+//				Interval::inf(b.y), Interval::sup(b.y));
+		if (b.is_empty())
+			continue;
+		if (s.fill) {
+			cairo_rectangle(s.cr, 
+					Interval::inf(b.x),
+					Interval::inf(b.y),
+					Interval::wid(b.x)+1,
+					Interval::wid(b.y)+1);
+			s.set_source_color(s.fill_color);
+			cairo_fill(s.cr);
+		}
+		if (s.stroke) {
+			s.set_source_color(s.stroke_color);
+			double wx = Interval::wid(b.x);
+			double wy = Interval::wid(b.y);
+			if (((int)round(s.stroke_width) & 1) == 1) {
+				if (wx < 1.0 || wy < 1.0) {
+					cairo_rectangle(s.cr, Interval::inf(b.x), Interval::inf(b.y), 1.0, 1.0);
+					cairo_fill(s.cr);
+				}
+				else {
+					cairo_rectangle(s.cr, Interval::inf(b.x)+0.5, Interval::inf(b.y)+0.5, wx, wy);
+					cairo_set_line_width(s.cr, s.stroke_width);
+					cairo_stroke(s.cr);
+				}
+			}
+			else {
+				cairo_rectangle(s.cr, Interval::inf(b.x), Interval::inf(b.y), wx+1.0, wy+1.0);
+				cairo_set_line_width(s.cr, s.stroke_width);
+				cairo_stroke(s.cr);
+			}
+		}
+	}
+}
+
+
+void P1788Figure::Command::exec(State& s)
+{
+	cairo_set_line_cap(s.cr, CAIRO_LINE_CAP_SQUARE);
+	cairo_set_line_join(s.cr, CAIRO_LINE_JOIN_MITER);
+	switch (m_type) {
+		case P1788Figure::Command::STROKE:
+//			printf("STROKE: %d\n", m_bool);
+			s.stroke = m_bool;
+			break;
+		case P1788Figure::Command::FILL:
+//			printf("FILL: %d\n", m_bool);
+			s.fill = m_bool;
+			break;
+		case P1788Figure::Command::STROKE_WIDTH:
+//			printf("STROKE_WIDTHT: %f\n", m_float);
+			s.stroke_width = m_float;
+			break;
+		case P1788Figure::Command::STROKE_COLOR:
+//			printf("STROKE_COLOR: 0x%08x\n", m_uint);
+			s.stroke_color = m_uint;
+			break;
+		case P1788Figure::Command::FILL_COLOR:
+//			printf("FILL_COLOR: 0x%08x\n", m_uint);
+			s.fill_color = m_uint;
+			break;
+		case P1788Figure::Command::DRAW_BOXES:
+//			printf("DRAW_BOXES (%lu)\n", m_boxes.size());
+			P1788Figure_print_boxes(s, m_boxes);
+			break;
+		default:
+//			printf("ERROR BAD COMMAND TYPE\n");
+			break;
+	}
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+}
+
+
+size_t P1788Figure::Command::allocated_size() const
+{
+	size_t r = sizeof(P1788Figure::Command);
+	if (m_type == P1788Figure::Command::DRAW_BOXES)
+		r += m_boxes.capacity()*sizeof(Box);
+	return r;
+}
+
+
+static cairo_status_t P1788Figure_write_func(void *closure, const unsigned char *data, unsigned int length)
+{
+	std::string& str = *(std::string*)closure;
+	str.append((const char*)data, length);
+	return CAIRO_STATUS_SUCCESS;
+}
+
+
+#ifdef CAIRO_HAS_IMAGE_SURFACE
+void P1788Figure::Figure::write_png(const std::string& file_name)
+{
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_write_to_png(imgsurf, file_name.c_str()));
+	cairo_surface_destroy(imgsurf);
+}
+
+std::string P1788Figure::Figure::to_png()
+{
+	std::string str;
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_write_to_png_stream(imgsurf, P1788Figure_write_func, &str));
+	cairo_surface_destroy(imgsurf);
+	return str;
+}
+#endif
+
+
+#ifdef CAIRO_HAS_SVG_SURFACE
+void P1788Figure::Figure::write_svg(const std::string& file_name)
+{
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_svg_surface_create(file_name.c_str(), s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_svg_surface_set_document_unit(imgsurf, CAIRO_SVG_UNIT_PX);
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_surface_destroy(imgsurf);
+}
+
+std::string P1788Figure::Figure::to_svg()
+{
+	std::string str;
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_svg_surface_create_for_stream(
+			P1788Figure_write_func, &str, s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_svg_surface_set_document_unit(imgsurf, CAIRO_SVG_UNIT_PX);
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_surface_destroy(imgsurf);
+	return str;
+}
+#endif
+
+
+#ifdef CAIRO_HAS_PDF_SURFACE
+void P1788Figure::Figure::write_pdf(const std::string& file_name)
+{
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_pdf_surface_create(file_name.c_str(), s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	if (!m_title.empty())
+		cairo_pdf_surface_set_metadata(imgsurf, CAIRO_PDF_METADATA_TITLE, m_title.c_str());
+	cairo_pdf_surface_set_metadata(imgsurf, CAIRO_PDF_METADATA_CREATOR, "Created with P1788 (https://gitlab.ensta-bretagne.fr/bollenth/p1788)");
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_surface_destroy(imgsurf);
+}
+
+std::string P1788Figure::Figure::to_pdf()
+{
+	std::string str;
+	State s(this);
+	cairo_surface_t *imgsurf = cairo_pdf_surface_create_for_stream(
+			P1788Figure_write_func, &str, s.figwidth, s.figheight);
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	if (!m_title.empty())
+		cairo_pdf_surface_set_metadata(imgsurf, CAIRO_PDF_METADATA_TITLE, m_title.c_str());
+	cairo_pdf_surface_set_metadata(imgsurf, CAIRO_PDF_METADATA_CREATOR, "Created with P1788 (https://gitlab.ensta-bretagne.fr/bollenth/p1788)");
+	s.cr = cairo_create(imgsurf);
+	exec_commands(s);
+	s.decorate();
+	P1788Figure_check_cairo_status(cairo_status(s.cr));
+	P1788Figure_check_cairo_status(cairo_surface_status(imgsurf));
+	cairo_surface_destroy(imgsurf);
+	return str;
+}
+#endif
+
+
+P1788Figure::Figure::Figure() :
+	m_width(0),
+	m_height(0),
+	m_xlim(),
+	m_ylim(),
+	m_xlabel(),
+	m_ylabel(),
+	m_title(),
+	m_bold_title(false),
+	m_do_print_graduation(true),
+	m_graduation_font("Sans"),
+	m_graduation_font_size(11.0f),
+	m_graduation_color(0x000000ffU),
+	m_graduation_stroke_width(1.0f),
+	m_label_font_size(0.0f),
+	m_title_font_size(0.0f),
+	m_do_stroke(true),
+	m_stroke_color(0x000000ffU),
+	m_stroke_width(1.0f),
+	m_do_fill(true),
+	m_fill_color(0x808080ffU),
+//	m_background_color(0xffffffffU),
+	m_background_color(0xffffff00U),
+	m_commands()
+{
+	m_commands.reserve(10);
+}
+
+
+void P1788Figure::Figure::reset()
+{
+	m_width = 0;
+	m_height = 0;
+	m_xlim = Interval();
+	m_ylim = Interval();
+	m_xlabel.clear();
+	m_ylabel.clear();
+	m_title.clear();
+	m_bold_title = false;
+	m_do_print_graduation = true;
+	m_graduation_font = "Sans";
+	m_graduation_color = 0x000000ffU;
+	m_graduation_stroke_width = 1.0f;
+	m_graduation_font_size = 11.0f;
+	m_label_font_size = 0.0f;
+	m_title_font_size = 0.0f;
+	m_do_stroke = true;
+	m_stroke_color = 0x000000ffU;
+	m_stroke_width = 1.0f;
+	m_do_fill = true;
+	m_fill_color = 0x808080ffU;
+	m_background_color = 0xffffff00U;
+	m_commands.clear();
+}
+
+
+// P1788Figure::Figure::~Figure()
+// {
+// 	const size_t l = m_commands.size();
+// 	for (size_t i = 0; i < l; i++)
+// 		delete m_commands[i];
+// 
+// }
+
+
+void P1788Figure::Figure::exec_commands(State& s)
+{
+	if ((m_background_color & 0xff) != 0x00) {
+		s.set_source_color(m_background_color);
+		cairo_paint(s.cr);
+	}
+	const size_t l = m_commands.size();
+	for (size_t i = 0; i < l; i++)
+		m_commands[i].exec(s);
+}
+
+
+void P1788Figure::Figure::cmd_stroke(bool b)
+{
+	if (b != m_do_stroke) {
+		m_do_stroke = b;
+		m_commands.emplace_back(Command::STROKE, b);
+//		if (b) {
+//			if (!m_stroke_color.empty())
+//				cmd_stroke_color(m_stroke_color);
+//			if (m_stroke_width > 0.0f)
+//				cmd_stroke_width(m_width);
+//		}
+	}
+}
+
+
+void P1788Figure::Figure::cmd_stroke_color(unsigned int c)
+{
+	if (c != m_stroke_color) {
+		m_stroke_color = c;
+		m_commands.emplace_back(Command::STROKE_COLOR, c);
+	}
+}
+
+
+void P1788Figure::Figure::cmd_stroke_width(float sw)
+{
+	if (sw <= 0.0f) return;
+	if (sw != m_stroke_width) {
+		m_stroke_width = sw;
+		m_commands.emplace_back(Command::STROKE_WIDTH, sw);
+	}
+}
+
+
+void P1788Figure::Figure::cmd_fill(bool b)
+{
+	if (b != m_do_fill) {
+		m_do_fill = b;
+		m_commands.emplace_back(Command::FILL, b);
+	}
+}
+
+
+void P1788Figure::Figure::cmd_fill_color(unsigned int c)
+{
+	if (c != m_fill_color) {
+		m_fill_color = c;
+		m_commands.emplace_back(Command::FILL_COLOR, c);
+	}
+}
+
+
+void P1788Figure::Figure::cmd_draw_box(const IntervalVector& iv)
+{
+	if (iv.size() < 2 || Interval::is_empty(iv[0]) || Interval::is_empty(iv[1])) return;
+	Box b(iv[0], iv[1]);
+	if (m_commands.size() > 0 && m_commands.back().is_a_draw_box_command())
+		m_commands.back().push_box(b);
+	else
+		m_commands.emplace_back(Command::DRAW_BOXES, b);
+}
+
+
+void P1788Figure::Figure::cmd_draw_boxes(const std::vector<IntervalVector*>& bv)
+{
+	const size_t vsize = bv.size();
+	if (vsize < 1) return;
+	size_t i;
+	std::vector<Box> v;
+	v.reserve(vsize);
+	for (i = 0; i < vsize; i++) {
+		const IntervalVector& e = *bv[i];
+		if (e.size() < 2 || Interval::is_empty(e[0]) || Interval::is_empty(e[1])) continue;
+		v.emplace_back(e[0], e[1]);
+	}
+	m_commands.emplace_back(Command::DRAW_BOXES, std::move(v));
+}
+
+
+void P1788Figure::Figure::cmd_draw_boxes(std::vector<Box>&& bv)
+{
+	if (bv.size() < 1) return;
+	m_commands.emplace_back(Command::DRAW_BOXES, std::move(bv));
+}
+
+
+void P1788Figure::Figure::set_title(const std::string& s)
+{
+	m_title = s;
+}
+
+
+void P1788Figure::Figure::set_background_color(unsigned int c)
+{
+	m_background_color = c;
+}
+
+
+void P1788Figure::Figure::set_title_bold(bool b)
+{
+	m_bold_title = b;
+}
+
+
+void P1788Figure::Figure::set_width(int width)
+{
+	if (width <= 0)
+		m_width = 0;
+	else
+		m_width  = std::max(std::min((unsigned int)width, 3840U), 10U);
+}
+
+
+void P1788Figure::Figure::set_height(int height)
+{
+	if (height <= 0)
+		m_height = 0;
+	else
+		m_height = std::max(std::min((unsigned int)height, 3840U), 10U);
+}
+
+
+void P1788Figure::Figure::set_xlabel(const std::string& l)
+{
+	m_xlabel = l;
+}
+
+
+void P1788Figure::Figure::set_ylabel(const std::string& l)
+{
+	m_ylabel = l;
+}
+
+
+void P1788Figure::Figure::set_xlimit(const Interval& l)
+{
+	if (Interval::is_common_interval(l))
+		m_xlim = l;
+	else
+		m_xlim = Interval();
+}
+
+
+void P1788Figure::Figure::set_ylimit(const Interval& l)
+{
+	if (Interval::is_common_interval(l))
+		m_ylim = l;
+	else
+		m_ylim = Interval();
+}
+
+
+void P1788Figure::Figure::set_print_graduations(bool b)
+{
+	m_do_print_graduation = b;
+}
+
+
+void P1788Figure::Figure::set_graduation_font(const std::string& s)
+{
+	if (s.empty())
+		m_graduation_font = std::string("Sans");
+	else
+		m_graduation_font = s;
+}
+
+
+void P1788Figure::Figure::set_graduation_font_size(float s)
+{
+	if (s > 0.0)
+		m_graduation_font_size = s;
+	else
+		m_graduation_font_size = 11.0f;
+}
+
+
+void P1788Figure::Figure::set_label_font_size(float s)
+{
+	m_label_font_size = std::max(0.0f, std::min(128.0f, s));
+}
+
+
+
+void P1788Figure::Figure::set_title_font_size(float s)
+{
+	m_title_font_size = std::max(0.0f, std::min(128.0f, s));
+}
+
+
+double P1788Figure::Figure::label_font_size() const
+{
+	if (m_label_font_size <= 0.0f)
+		return 1.0909090909090908 * m_graduation_font_size;
+	return m_label_font_size;
+}
+
+
+double P1788Figure::Figure::title_font_size() const
+{
+	if (m_title_font_size <= 0.0f)
+		return 1.2272727272727273 * m_graduation_font_size;
+	return m_title_font_size;
+}
+
+
+void P1788Figure::Figure::set_graduation_color(unsigned int c)
+{
+	m_graduation_color = c;
+}
+
+
+void P1788Figure::Figure::set_graduation_stroke_width(float s)
+{
+	if (s > 0.0)
+		m_graduation_stroke_width = s;
+}
+
+
+size_t P1788Figure::Figure::allocated_size() const
+{
+	size_t r = sizeof(Figure);
+	r += m_xlabel.capacity();
+	r += m_ylabel.capacity();
+	r += m_title.capacity();
+	r += m_graduation_font.capacity();
+	for (auto c = m_commands.cbegin(); c < m_commands.cend(); ++c)
+		r += c->allocated_size();
+	return r;
+}
+
+
+void P1788Figure::Figure::find_unbounded_limits(Box& limits) const
+{
+	double x_min = std::numeric_limits<double>::quiet_NaN();
+	double x_max = std::numeric_limits<double>::quiet_NaN();
+	double y_min = std::numeric_limits<double>::quiet_NaN();
+	double y_max = std::numeric_limits<double>::quiet_NaN();
+
+	for (auto cmd = m_commands.cbegin(); cmd < m_commands.cend(); ++cmd) {
+		if (!cmd->is_a_draw_box_command())
+			continue;
+		const std::vector<Box>& boxes = cmd->boxes();
+		for (auto b = boxes.cbegin(); b < boxes.cend(); ++b) {
+			if (Interval::is_empty(b->x) || Interval::is_empty(b->y))
+				continue;
+			x_min = fmin(x_min, Interval::inf(b->x));
+			x_max = fmax(x_max, Interval::sup(b->x));
+			y_min = fmin(y_min, Interval::inf(b->y));
+			y_max = fmax(y_max, Interval::sup(b->y));
+		}
+	}
+
+	limits.x = Interval(x_min, x_max);
+	limits.y = Interval(y_min, y_max);
+}
+
+
+void P1788Figure::Figure::find_limits(Box& limits, Box& nice_limits) const
+{
+	double x_finitemin = std::numeric_limits<double>::quiet_NaN();
+	double x_finitemax = std::numeric_limits<double>::quiet_NaN();
+	double y_finitemin = std::numeric_limits<double>::quiet_NaN();
+	double y_finitemax = std::numeric_limits<double>::quiet_NaN();
+
+	for (auto cmd = m_commands.cbegin(); cmd < m_commands.cend(); ++cmd) {
+		if (!cmd->is_a_draw_box_command())
+			continue;
+		const std::vector<Box>& boxes = cmd->boxes();
+		for (auto b = boxes.cbegin(); b < boxes.cend(); ++b) {
+			if (Interval::is_empty(b->x) || Interval::is_empty(b->y))
+				continue;
+			if (std::isfinite(Interval::inf(b->x)))
+				x_finitemin = fmin(x_finitemin, Interval::inf(b->x));
+			if (std::isfinite(Interval::sup(b->x)))
+				x_finitemax = fmax(x_finitemax, Interval::sup(b->x));
+			if (std::isfinite(Interval::inf(b->y)))
+				y_finitemin = fmin(y_finitemin, Interval::inf(b->y));
+			if (std::isfinite(Interval::sup(b->y)))
+				y_finitemax = fmax(y_finitemax, Interval::sup(b->y));
+		}
+	}
+
+	if (std::isfinite(x_finitemin) && std::isfinite(x_finitemax))
+		limits.x = Interval(x_finitemin, x_finitemax);
+	else if (std::isfinite(x_finitemin))
+		limits.x = Interval(x_finitemin, x_finitemin + 1.0);
+	else if (std::isfinite(x_finitemax))
+		limits.x = Interval(x_finitemax - 1.0, x_finitemax);
+	else
+		limits.x = Interval(-1.0, 1.0);
+
+	if (std::isfinite(y_finitemin) && std::isfinite(y_finitemax))
+		limits.y = Interval(y_finitemin, y_finitemax);
+	else if (std::isfinite(y_finitemin))
+		limits.y = Interval(y_finitemin, y_finitemin + 1.0);
+	else if (std::isfinite(y_finitemax))
+		limits.y = Interval(y_finitemax - 1.0, y_finitemax);
+	else
+		limits.y = Interval(-1.0, 1.0);
+
+	TickAxis tk(limits.x, 10);
+	nice_limits.x = Interval(tk.nice_min(), tk.nice_max());
+	tk.set_min_max(limits.y);
+	nice_limits.y = Interval(tk.nice_min(), tk.nice_max());
+}
+
+
+P1788Figure::State::State(Figure* figure) :
+	cr(NULL),
+	figure(figure),
+	width(0), height(0),
+	m_Sx(1.0), m_Sy(1.0), m_Tx(0.0), m_Ty(0.0),
+	stroke(true),
+	stroke_width(1.0f),
+	stroke_color(0x000000ffU),
+	fill(true),
+	fill_color(0x808080ffU),
+	frame_box(),
+	figwidth(0), figheight(0),
+	top_offset(0), bot_offset(0), left_offset(0), right_offset(0),
+	xtickaxis(NULL), ytickaxis(NULL),
+	x_grad(), y_grad(),
+	xlabel(figure->xlabel()),
+	ylabel(figure->ylabel()),
+	title(figure->title()),
+	max_x_grad_height(0.0f), max_y_grad_width(0.0f), char_height(0.0f), char_width(0.0f)
+{
+	Box limits, nice_limits;
+	bool x_is_bad = !Interval::is_common_interval(figure->xlim()) || Interval::is_singleton(figure->xlim());
+	bool y_is_bad = !Interval::is_common_interval(figure->ylim()) || Interval::is_singleton(figure->ylim());
+	if (x_is_bad || y_is_bad) {
+		figure->find_limits(limits, nice_limits);
+		if (x_is_bad)
+			limits.x = nice_limits.x;
+		else
+			limits.x = figure->xlim();
+		if (y_is_bad)
+			limits.y = nice_limits.y;
+		else
+			limits.y = figure->ylim();
+	}
+	else {
+		limits.x = figure->xlim();
+		limits.y = figure->ylim();
+	}
+
+	double aratio = Interval::wid(limits.x) / Interval::wid(limits.y);
+//	printf("==================\nxl: %g\nxr: %g\nyt: %g, yb: %g\nwidth: %d\nheight: %d\nratio: %g\n================\n",
+//			Interval::inf(limits.x), Interval::sup(limits.x), Interval::inf(limits.y), Interval::sup(limits.y),
+//			figure->width(), figure->height(), aratio);
+	if (figure->width() < 1 && figure->height() < 1) {
+		width = 512;
+		height = (int)round((double)width / aratio) & ~1;
+	}
+	else if (figure->width() < 1) {
+		height = figure->height();
+		width = (int)round(aratio*(double)height) & ~1;
+	}
+	else if (figure->height() < 1) {
+		width = figure->width();
+		height = (int)round((double)width / aratio) & ~1;
+	}
+	else {
+		width = figure->width();
+		height = figure->height();
+	}
+	width  = std::max(std::min((unsigned int)width,  3840U), 10U);
+	height = std::max(std::min((unsigned int)height, 3840U), 10U);
+//	printf("width: %u\nheight: %u\n", width, height);
+
+	if (figure->print_graduations()) {
+		xtickaxis = new TickAxis(limits.x, (int)round((double)width  / 70.0));
+		ytickaxis = new TickAxis(limits.y, (int)round((double)height / 70.0));
+		calculate_spacings();
+		frame_box = Box(Interval((double)left_offset, (double)(left_offset+width-1)), Interval((double)top_offset, (double)(top_offset+height-1)));
+		figwidth = left_offset + width + right_offset;
+		figheight = top_offset + height + bot_offset;
+	}
+	else {
+		frame_box = Box(Interval(0.0, (double)(width-1)), Interval(0.0, (double)(height-1)));
+		figwidth = width;
+		figheight = height;
+	}
+	double rl = Interval::inf(limits.x);
+	double rr = Interval::sup(limits.x);
+	double rb = Interval::inf(limits.y);
+	double rt = Interval::sup(limits.y);
+	double sl = Interval::inf(frame_box.x);
+	double sr = Interval::sup(frame_box.x);
+	double sb = Interval::sup(frame_box.y);
+	double st = Interval::inf(frame_box.y);
+	m_Sx = (sl-sr)/(rl-rr);
+	m_Sy = (sb-st)/(rb-rt);
+	m_Tx = (rl*sr-rr*sl)/(rl-rr);
+	m_Ty = (rb*st-rt*sb)/(rb-rt);
+
+	stroke = true;
+	stroke_width = 1.0f;
+	stroke_color = 0x000000ffU;
+	fill = true;
+	fill_color = 0x808080ffU;
+}
+
+
+P1788Figure::State::~State()
+{
+	if (cr)
+		cairo_destroy(cr);
+	if (xtickaxis)
+		delete xtickaxis;
+	if (ytickaxis)
+		delete ytickaxis;
+}
+
+
+void P1788Figure::State::set_font_options(cairo_t *ctx)
+{
+	cairo_select_font_face(ctx, figure->graduation_font().c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+	cairo_set_font_size(ctx, figure->graduation_font_size());
+	if ((figure->graduation_color() & 0xff) != 0xff) {
+#if 1
+		cairo_font_options_t *font_options = cairo_font_options_create();
+		cairo_font_options_set_antialias(font_options, CAIRO_ANTIALIAS_SUBPIXEL); // DEFAULT GRAY SUBPIXEL
+		cairo_font_options_set_hint_style(font_options, CAIRO_HINT_STYLE_MEDIUM); // SLIGHT MEDIUM FULL
+		cairo_font_options_set_hint_metrics(font_options, CAIRO_HINT_METRICS_ON); // ON OFF
+		cairo_set_font_options(ctx, font_options);
+		cairo_font_options_destroy(font_options);
+#else
+		cairo_font_options_t *font_options = cairo_font_options_create();
+		cairo_font_options_set_antialias(font_options, CAIRO_ANTIALIAS_GRAY);//DEFAULT SUBPIXEL);
+		//cairo_font_options_set_subpixel_order(font_options, CAIRO_SUBPIXEL_ORDER_RGB); //DEFAULT);
+		cairo_font_options_set_hint_style(font_options, CAIRO_HINT_STYLE_MEDIUM);//SLIGHT MEDIUM FULL);
+		cairo_font_options_set_hint_metrics(font_options, CAIRO_HINT_METRICS_ON); //ON OFF);
+		cairo_set_font_options(ctx, font_options);
+		cairo_font_options_destroy(font_options);
+#endif
+	}
+}
+
+
+void P1788Figure::State::calculate_spacings()
+{
+	if (!figure->print_graduations()) return;
+
+	/* Create a temporary surface and context to get font extents */
+	cairo_surface_t *tmpsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 10, 10);
+	cairo_t * tmpcr = cairo_create(tmpsurf);
+	cairo_surface_destroy(tmpsurf);
+
+	set_font_options(tmpcr);
+
+	double max_x_grad_width = 0.0;
+	max_x_grad_height = 0.0f;
+	max_y_grad_width  = 0.0f;
+	cairo_text_extents_t te;
+
+	cairo_text_extents(tmpcr, "bdfghjklpqtbHM", &te);
+	char_height = ceil(te.height);
+	cairo_text_extents(tmpcr, "6", &te);
+	char_width = ceil((te.width + char_height)/2.0);
+
+	x_grad = xtickaxis->get_coordinate_strings();
+	for (auto s = x_grad.begin(); s < x_grad.end(); ++s) {
+		cairo_text_extents(tmpcr, s->str.c_str(), &te);
+		s->width = te.width;
+		s->height = te.height;
+		s->x_bearing = te.x_bearing;
+		s->y_bearing = te.y_bearing;
+		max_x_grad_height = std::max(max_x_grad_height, (float)te.height);
+		max_x_grad_width  = std::max(max_x_grad_width,  te.width);
+	}
+
+	y_grad = ytickaxis->get_coordinate_strings();
+	for (auto s = y_grad.begin(); s < y_grad.end(); ++s) {
+		cairo_text_extents(tmpcr, s->str.c_str(), &te);
+		s->width = te.width;
+		s->height = te.height;
+		s->x_bearing = te.x_bearing;
+		s->y_bearing = te.y_bearing;
+//		printf("- \"%s\" -> %f\n", s->str.c_str(), s->width);
+		max_y_grad_width = std::max(max_y_grad_width, (float)te.width);
+	}
+
+	if (!xlabel.empty()) {
+		cairo_set_font_size(tmpcr, figure->label_font_size());
+		cairo_text_extents(tmpcr, xlabel.str.c_str(), &te);
+		xlabel.width = te.width;
+		xlabel.height = te.height;
+		xlabel.x_bearing = te.x_bearing;
+		xlabel.y_bearing = te.y_bearing;
+	}
+
+	if (!ylabel.empty()) {
+		cairo_set_font_size(tmpcr, figure->label_font_size());
+		cairo_text_extents(tmpcr, ylabel.str.c_str(), &te);
+		ylabel.width = te.width;
+		ylabel.height = te.height;
+		ylabel.x_bearing = te.x_bearing;
+		ylabel.y_bearing = te.y_bearing;
+	}
+
+	if (!title.empty()) {
+		cairo_set_font_size(tmpcr, figure->title_font_size());
+		if (figure->title_bold())
+			cairo_select_font_face(tmpcr, figure->graduation_font().c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+		cairo_text_extents(tmpcr, title.str.c_str(), &te);
+		title.width = te.width;
+		title.height = te.height;
+		title.x_bearing = te.x_bearing;
+		title.y_bearing = te.y_bearing;
+	}
+
+	double bot_offset_d;
+	if (xlabel.empty())
+		bot_offset_d = char_height + max_x_grad_height + char_height;
+	else
+		bot_offset_d = char_height + max_x_grad_height + 3.0*xlabel.height;
+
+	double left_offset_d;
+	if (ylabel.empty())
+		left_offset_d = char_width + max_y_grad_width + char_height;
+	else
+		left_offset_d = char_width + max_y_grad_width + 3.0*ylabel.height;
+
+	double top_offset_d;
+	if (title.empty())
+		top_offset_d = char_height;
+	else
+		top_offset_d = 3.0*title.height;
+
+	double right_offset_d = std::max((double)char_height, char_width + max_x_grad_width/2.0);
+
+	bot_offset = ceilf(bot_offset_d);
+	top_offset = ceilf(top_offset_d);
+	right_offset = ceilf(right_offset_d);
+	left_offset = ceilf(left_offset_d);
+
+//	printf("---------------------------\n");
+//	printf("char_height: %f\n", char_height);
+//	printf("char_width: %f\n", char_width);
+//	printf("mx_x_height: %f\n", max_x_grad_height);
+//	printf("mx_y_width: %f\n", max_y_grad_width);
+//	printf("---------------------------\n");
+
+	cairo_destroy(tmpcr);
+}
+
+
+void P1788Figure::State::real_box_to_screen_box(const Box& rb, Box& sb) const
+{
+	Interval sx(m_Sx, m_Sx), tx(m_Tx, m_Tx), sy(m_Sy, m_Sy), ty(m_Ty, m_Ty);
+	sb.x = Interval::intersection(rb.x * sx + tx, frame_box.x);
+	sb.y = Interval::intersection(rb.y * sy + ty, frame_box.y);
+	sb.x = Interval(round(Interval::inf(sb.x)), round(Interval::sup(sb.x)));
+	sb.y = Interval(round(Interval::inf(sb.y)), round(Interval::sup(sb.y)));
+}
+
+
+void P1788Figure::State::set_source_color(unsigned int c)
+{
+	if (!cr) return;
+	double r = (double)((c >> 24) & 0xff) / 255.0;
+	double g = (double)((c >> 16) & 0xff) / 255.0;
+	double b = (double)((c >>  8) & 0xff) / 255.0;
+	double a = (double)( c        & 0xff) / 255.0;
+	if (a == 1.0)
+		cairo_set_source_rgb(cr, r, g, b);
+	else
+		cairo_set_source_rgba(cr, r, g, b, a);
+}
+
+
+void P1788Figure::State::decorate()
+{
+	if (!figure->print_graduations() || !cr) return;
+
+	/* Draw frame */
+	cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
+	set_source_color(figure->graduation_color());
+	cairo_set_line_width(cr, figure->graduation_stroke_width());
+	if (((int)round(figure->graduation_stroke_width()) & 1) == 1)
+		cairo_rectangle(cr, Interval::inf(frame_box.x)+0.5, Interval::inf(frame_box.y)+0.5, Interval::wid(frame_box.x), Interval::wid(frame_box.y));
+	else
+		cairo_rectangle(cr, Interval::inf(frame_box.x), Interval::inf(frame_box.y), Interval::wid(frame_box.x)+1, Interval::wid(frame_box.y)+1);
+	cairo_stroke(cr);
+
+	set_font_options(cr);
+
+	cairo_set_line_width(cr, 1.0);
+
+	/* X axis */
+	for (auto s = x_grad.cbegin(); s < x_grad.cend(); ++s) {
+		double x = round(s->value * m_Sx + m_Tx);
+		if (x < Interval::inf(frame_box.x) || x > Interval::sup(frame_box.x))
+			continue;
+		cairo_move_to(cr, x+0.5, Interval::sup(frame_box.y)+0.5);
+		cairo_rel_line_to(cr, 0.0, -ceil(char_width*0.7));
+		cairo_stroke(cr);
+		cairo_move_to(cr, x+0.5, Interval::inf(frame_box.y)+0.5);
+		cairo_rel_line_to(cr, 0.0, ceil(char_width*0.7));
+		cairo_stroke(cr);
+
+		cairo_move_to(cr,
+				round(x - s->width/2.0 - s->x_bearing + 0.5),
+				round(Interval::sup(frame_box.y) + char_height + max_x_grad_height));
+		cairo_show_text(cr, s->str.c_str());
+	}
+
+	/* Y axis */
+	for (auto s = y_grad.cbegin(); s < y_grad.cend(); ++s) {
+		double y = round(s->value * m_Sy + m_Ty);
+		if (y < Interval::inf(frame_box.y) || y > Interval::sup(frame_box.y))
+			continue;
+		cairo_move_to(cr, Interval::inf(frame_box.x)+0.5, y+0.5);
+		cairo_rel_line_to(cr, ceil(char_width*0.7), 0);
+		cairo_stroke(cr);
+		cairo_move_to(cr, Interval::sup(frame_box.x)+0.5, y+0.5);
+		cairo_rel_line_to(cr, -ceil(char_width*0.7), 0);
+		cairo_stroke(cr);
+
+		cairo_move_to(cr,
+				round(Interval::inf(frame_box.x) - char_width - s->width - s->x_bearing),
+				round(y - s->y_bearing - s->height/2.0 + 0.5));
+		cairo_show_text(cr, s->str.c_str());
+	}
+
+	cairo_set_font_size(cr, figure->label_font_size());
+
+	/* X label */
+	if (!xlabel.empty()) {
+		cairo_move_to(cr,
+				round(Interval::inf(frame_box.x) + Interval::wid(frame_box.x)/2.0 - xlabel.width/2 - xlabel.x_bearing),
+				round(Interval::sup(frame_box.y) + char_height + max_x_grad_height + 2.0*xlabel.height));
+		cairo_show_text(cr, xlabel.str.c_str());
+	}
+
+	/* Y label */
+	if (!ylabel.empty()) {
+		cairo_save(cr);
+		cairo_rotate(cr, -M_PI/2.0);
+
+		cairo_move_to(cr,
+				round(-Interval::inf(frame_box.y) - ylabel.width/2.0 - ylabel.x_bearing - Interval::wid(frame_box.y)/2.0),
+				round(Interval::inf(frame_box.x) - char_width - max_y_grad_width - ylabel.height));
+		cairo_show_text(cr, ylabel.str.c_str());
+		cairo_restore(cr);
+	}
+
+	/* Title */
+	if (!title.empty()) {
+		cairo_set_font_size(cr, figure->title_font_size());
+		if (figure->title_bold())
+			cairo_select_font_face(cr, figure->graduation_font().c_str(), CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+		cairo_move_to(cr,
+				round(Interval::inf(frame_box.x) + Interval::wid(frame_box.x)/2.0 - title.width/2 - title.x_bearing),
+				round(title.height - title.y_bearing));
+		cairo_show_text(cr, title.str.c_str());
+	}
+}
+
+
+P1788Figure::TickAxis::TickAxis(const Interval& interval, int nb_ticks) :
+	m_interval(Interval::is_common_interval(interval) ? interval : Interval(0.0, 1.0)),
+	m_nice_min(0.0),
+	m_nice_max(0.0),
+	m_tick_spacing(0.0),
+	m_nb_ticks(std::max(2, nb_ticks))
+{
+	update();
+}
+
+
+static double P1788Figure_round_double(double x, int nbits)
+{
+	/* https://stackoverflow.com/questions/41583249/how-to-round-a-double-float-to-binary-precision */
+	int c = 1 | (1 << nbits);
+	double t = c * x;
+	return x - t + t;
+}
+
+
+std::vector<double> P1788Figure::TickAxis::get_coordinates() const
+{
+	std::vector<double> r;
+	double i = 0.0;
+	double d;
+	const double mx = Interval::sup(m_interval) + Interval::wid(m_interval)/10000.0f;
+
+	while (1) {
+		d = m_nice_min + i*m_tick_spacing;
+		if (d > mx)
+			break;
+		else
+			r.push_back(std::abs(d) <= 1e-15 ? 0.0 : d);
+		i = i + 1.0;
+	}
+
+	return r;
+}
+
+
+void P1788Figure::TickAxis::update()
+{
+	const double rng = Interval::wid(m_interval);
+	const double minimum = rng / (double)m_nb_ticks;
+	const double magnitude = exp10(floor(log10(minimum)));
+	const double residual = minimum / magnitude;
+
+	if (residual > 5.0)
+		m_tick_spacing = 10.0 * magnitude;
+	else if (residual > 2.0)
+		m_tick_spacing =  5.0 * magnitude;
+	else if (residual > 1.0)
+		m_tick_spacing =  2.0 * magnitude;
+	else
+		m_tick_spacing =  1.0 * magnitude;
+
+	const int nbits = 1;
+//	printf("--------------------------------------\n");
+//	printf("min: %.16f\n", Interval::inf(m_interval));
+//	printf("m_tick_spacing: %.16f\n", m_tick_spacing);
+//	printf("(min/m_tick_spacing): %.16f => %.16f\n", Interval::inf(m_interval)/m_tick_spacing,
+//			P1788Figure_round_double(Interval::inf(m_interval)/m_tick_spacing, nbits));
+//	printf("floor(min/m_tick_spacing): %.16f => %.16f\n", floor(Interval::inf(m_interval)/m_tick_spacing),
+//			floor(P1788Figure_round_double(Interval::inf(m_interval)/m_tick_spacing, nbits)));
+//	printf("floor(min/m_tick_spacing)*m_tick_spacing: %.16f => %.16f\n", floor(Interval::inf(m_interval)/m_tick_spacing)*m_tick_spacing,
+//			floor(P1788Figure_round_double(Interval::inf(m_interval)/m_tick_spacing, nbits))*m_tick_spacing);
+//	printf("--\n");
+//	printf("max: %.16f\n", Interval::sup(m_interval));
+//	printf("m_tick_spacing: %.16f\n", m_tick_spacing);
+//	printf("(max/m_tick_spacing): %.16f => %.16f\n", Interval::sup(m_interval)/m_tick_spacing,
+//			P1788Figure_round_double(Interval::sup(m_interval)/m_tick_spacing, nbits));
+//	printf("ceil(max/m_tick_spacing): %.16f => %.16f\n", ceil(Interval::sup(m_interval)/m_tick_spacing),
+//			ceil(P1788Figure_round_double(Interval::sup(m_interval)/m_tick_spacing, nbits)));
+//	printf("ceil(max/m_tick_spacing)*m_tick_spacing: %.16f => %.16f\n", ceil(Interval::sup(m_interval)/m_tick_spacing)*m_tick_spacing,
+//			ceil(P1788Figure_round_double(Interval::sup(m_interval)/m_tick_spacing, nbits))*m_tick_spacing);
+//	printf("--------------------------------------\n");
+	m_nice_min = P1788Figure_round_double(floor(P1788Figure_round_double(Interval::inf(m_interval) / m_tick_spacing, nbits)) * m_tick_spacing, nbits);
+	m_nice_max = P1788Figure_round_double( ceil(P1788Figure_round_double(Interval::sup(m_interval) / m_tick_spacing, nbits)) * m_tick_spacing, nbits);
+}
+
+
+#if 0
+static bool P1788Figure_all_doubles_are_integer(const std::vector<double>& v)
+{
+	bool r = true;
+	const size_t l = v.size();
+	for (size_t i = 0; i < l; i++) {
+		if ((double)((int)(v[i])) != v[i]) {
+			r = false;
+			break;
+		}
+	}
+	return r;
+}
+
+
+static std::string P1788Figure_double_to_string(double v, bool rm_point)
+{
+	std::string s = std::to_string(v);
+	int l = s.size();
+	int nl = l;
+	if (rm_point) {
+		while (nl > 1 && s[nl-1] == '0')
+			nl--;
+		if (nl > 1 && s[nl-1] == '.')
+			nl--;
+	}
+	else {
+		while (nl > 2 && s[nl-1] == '0' && s[nl-2] != '.')
+			nl--;
+	}
+	if (nl != l)
+		s.resize(nl);
+#else
+static P1788Figure::StringWithExtent P1788Figure_double_to_string(double v)
+{
+	std::ostringstream streamObj;
+	streamObj << v;
+	P1788Figure::StringWithExtent s(streamObj.str());
+#endif
+	return s;
+}
+
+
+static bool P1788Figure_one_is_not_integer(const std::vector<P1788Figure::StringWithExtent>& v)
+{
+	const size_t l = v.size();
+	for (size_t i = 0; i < l; i++) {
+		const std::string& str = v[i].str;
+		const size_t sl = str.length();
+		for (size_t j = 0; j < sl; j++) {
+			if ((str[j] < '0' || str[j] > '9') && str[j] != '-')
+				return true;
+		}
+	}
+	return false;
+}
+
+
+static bool P1788Figure_string_is_an_integer_string(const std::string& str)
+{
+	const size_t sl = str.length();
+	if (sl < 1)
+		return false;
+	for (size_t j = 0; j < sl; j++) {
+		if ((str[j] < '0' || str[j] > '9') && str[j] != '-')
+			return false;
+	}
+	return true;
+}
+
+
+static void P1788Figure_add_dot_zero_to_integer_strings(std::vector<P1788Figure::StringWithExtent>& v)
+{
+	const size_t l = v.size();
+	for (size_t i = 0; i < l; i++) {
+		if (P1788Figure_string_is_an_integer_string(v[i].str))
+			v[i].str += ".0";
+	}
+}
+
+
+std::vector<P1788Figure::StringWithExtent> P1788Figure::TickAxis::get_coordinate_strings() const
+{
+	std::vector<StringWithExtent> strs;
+	std::vector<double> coords(get_coordinates());
+//	bool rm_point = P1788Figure_all_doubles_are_integer(coords);
+	const size_t l = coords.size();
+	for (size_t i = 0; i < l; i++) {
+		strs.emplace_back(P1788Figure_double_to_string(coords[i]));
+		strs.back().value = coords[i];
+		//printf("%s\n", strs[i].str.c_str());
+	}
+
+	if (P1788Figure_one_is_not_integer(strs))
+		P1788Figure_add_dot_zero_to_integer_strings(strs);
+
+	return strs;
+}
+
+