p1788 0.1.0 → 1.0.0

data/ext/p1788/figure.hh

@@ -0,0 +1,294 @@
+/* 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/>. 
+ */
+
+#ifndef P1788_FIGURE_HH
+#define P1788_FIGURE_HH
+
+#include <string>
+#include <vector>
+#include <cairo/cairo.h>
+#include <p1788/p1788.hpp>
+
+using Interval = p1788::infsup::interval<double, p1788::flavor::infsup::setbased::mpfr_bin_ieee754_flavor>;
+using IntervalVector = std::vector<Interval>;
+//typedef p1788::infsup::interval<double, p1788::flavor::infsup::setbased::mpfr_bin_ieee754_flavor> Interval;
+//typedef std::vector<Interval> IntervalVector ;
+
+#if 0
+class Interval {
+public:
+	double inf;
+	double sup;
+	Interval() : inf(1), sup(-1) {}
+	Interval(double lb, double ub) : inf(lb), sup(ub) {}
+	bool is_empty() const { return (inf > sup); }
+	bool is_common() const { return true; }
+	double width() const { return (sup - inf); }
+	Interval operator&(const Interval& other) const {
+		if (is_empty() || other.is_empty() || sup < other.inf || inf > other.sup)
+			return Interval();
+		return Interval(std::max(inf, other.inf), std::min(sup, other.sup));
+	}
+	Interval operator+(const Interval& other) const {
+		return Interval(inf + other.inf, sup+other.sup);
+	}
+	Interval operator*(const Interval& other) const {
+		double a = inf*other.inf;
+		double b = inf*other.sup;
+		double c = sup*other.inf;
+		double d = sup*other.sup;
+		return Interval(
+				std::min(std::min(a, b), std::min(c, d)),
+				std::max(std::max(a, b), std::max(c, d)));
+	}
+};
+#endif
+
+
+namespace P1788Figure {
+
+
+class Box {
+public:
+	Interval x;
+	Interval y;
+
+	Box() : x(), y() {}
+	Box(const Interval& ix, const Interval& iy) : x(ix), y(iy) {}
+	Box(const Box& b) : x(b.x), y(b.y) {}
+	Box& operator=(const Box& b) { x = b.x; y = b.y; return *this; }
+	Box& operator=(Box&& b) { x = std::move(b.x); y = std::move(b.y); return *this; }
+	Box operator&(const Box& other) const { return Box(Interval::intersection(x, other.x), Interval::intersection(y, other.y)); }
+	bool is_empty() const { return (Interval::is_empty(x) || Interval::is_empty(y)); }
+};
+
+
+class StringWithExtent {
+public:
+	std::string str;
+	float width, height, x_bearing, y_bearing;
+	double value;
+	StringWithExtent() : str(), width(0.0f), height(0.0f), x_bearing(0.0f), y_bearing(0.0f), value(0.0) {}
+	StringWithExtent(const std::string& s) : str(s), width(0.0f), height(0.0f), x_bearing(0.0f), y_bearing(0.0f), value(0.0) {}
+	StringWithExtent(std::string&& s) : str(std::move(s)), width(0.0f), height(0.0f), x_bearing(0.0f), y_bearing(0.0f), value(0.0) {}
+	StringWithExtent(StringWithExtent&& s) :
+		str(std::move(s.str)), width(s.width), height(s.height), x_bearing(s.x_bearing), y_bearing(s.y_bearing), value(s.value) {}
+	bool empty() const { return str.empty(); }
+};
+
+
+class TickAxis {
+private:
+	Interval m_interval;
+	double   m_nice_min; 
+	double   m_nice_max; 
+	double   m_tick_spacing;
+	int      m_nb_ticks;
+
+	void update();
+
+public:
+	TickAxis(const Interval& interval, int nb_ticks);
+	void   set_min_max(const Interval& interval) { if (Interval::is_common_interval(interval)){m_interval = interval; update();} }
+	void   set_min_max(double mi, double mx) { set_min_max(Interval(mi, mx)); }
+	void   set_nb_ticks(int n) { if (n >= 2){m_nb_ticks = n; update();} }
+	double min() const { return Interval::inf(m_interval); }
+	double max() const { return Interval::sup(m_interval); }
+	double nice_min() const { return m_nice_min; }
+	double nice_max() const { return m_nice_max; }
+	int    nb_ticks() const { return m_nb_ticks; }
+	double tick_spacing() const { return m_tick_spacing; }
+	std::vector<double> get_coordinates() const;
+	std::vector<StringWithExtent> get_coordinate_strings() const;
+};
+
+
+class Figure;
+
+
+class State {
+public:
+	cairo_t     *cr; // cairo context
+	Figure      *figure;
+	unsigned int width, height;
+	double       m_Sx, m_Sy, m_Tx, m_Ty;
+	bool         stroke;
+	float        stroke_width;
+	unsigned int stroke_color;
+	bool         fill;
+	unsigned int fill_color;
+	Box          frame_box;
+	int          figwidth, figheight;
+	int          top_offset, bot_offset, left_offset, right_offset;
+	TickAxis    *xtickaxis, *ytickaxis;
+	std::vector<StringWithExtent> x_grad, y_grad;
+	StringWithExtent xlabel, ylabel, title;
+	float        max_x_grad_height, max_y_grad_width, char_height, char_width;
+
+	State(Figure* figure);
+	~State();
+	void decorate();
+	void real_box_to_screen_box(const Box& rb, Box& sb) const;
+	void set_source_color(unsigned int c);
+
+private:
+	void calculate_spacings();
+	void set_font_options(cairo_t*);
+};
+
+
+class Command {
+public:
+	typedef enum {
+		NONE         = 0x00,
+		STROKE       = 0x01,
+		FILL         = 0x02,
+		STROKE_WIDTH = 0x04,
+		STROKE_COLOR = 0x08,
+		FILL_COLOR   = 0x10,
+		DRAW_BOXES   = 0x20
+	} command_type_t;
+private:
+	command_type_t m_type;
+	union {
+		bool         m_bool;
+		float        m_float;
+		unsigned int m_uint;
+		std::vector<Box> m_boxes;
+	};
+public:
+//	Command();
+	Command(command_type_t, bool);
+	Command(command_type_t, float);
+	Command(command_type_t, unsigned int);
+	Command(command_type_t, std::vector<Box>&&);
+	Command(command_type_t, const Box&);
+	Command(Command&&);
+	~Command();
+	void exec(State& s);
+	command_type_t type() const { return m_type; }
+	bool is_a_draw_box_command() const { return (m_type == DRAW_BOXES); }
+	const std::vector<Box>& boxes() const { return m_boxes; }
+	void push_box(const Box&);
+	size_t allocated_size() const;
+};
+
+
+class Figure {
+private:
+	unsigned int m_width;
+	unsigned int m_height;
+	Interval     m_xlim;
+	Interval     m_ylim;
+	std::string  m_xlabel;
+	std::string  m_ylabel;
+	std::string  m_title;
+	bool         m_bold_title;
+	bool         m_do_print_graduation;
+	std::string  m_graduation_font;
+	float        m_graduation_font_size;
+	unsigned int m_graduation_color;
+	float        m_graduation_stroke_width;
+	float        m_label_font_size;
+	float        m_title_font_size;
+	bool         m_do_stroke;
+	unsigned int m_stroke_color;
+	float        m_stroke_width;
+	bool         m_do_fill;
+	unsigned int m_fill_color;
+	unsigned int m_background_color;
+	std::vector<Command> m_commands;
+
+public:
+	Figure();
+//	~Figure();
+
+	void cmd_stroke(bool);
+	void cmd_stroke_color(unsigned int);
+	void cmd_stroke_width(float);
+	void cmd_fill(bool);
+	void cmd_fill_color(unsigned int);
+	void cmd_draw_box(const IntervalVector&);
+	void cmd_draw_boxes(const std::vector<IntervalVector*>&);
+	void cmd_draw_boxes(std::vector<Box>&&);
+
+	void set_title(const std::string&);
+	void set_title_bold(bool);
+	void set_background_color(unsigned int c);
+	void set_width(int width);
+	void set_height(int height);
+	void set_xlabel(const std::string& l);
+	void set_ylabel(const std::string& l);
+	void set_xlimit(const Interval& l);
+	void set_ylimit(const Interval& l);
+	void set_print_graduations(bool b);
+	void set_graduation_font(const std::string& s);
+	void set_graduation_font_size(float s);
+	void set_graduation_color(unsigned int);
+	void set_graduation_stroke_width(float s);
+	void set_label_font_size(float s);
+	void set_title_font_size(float s);
+	void reset();
+
+	bool do_stroke() const { return m_do_stroke; }
+	double stroke_width() const { return (double)m_stroke_width; }
+	unsigned int stroke_color() const { return m_stroke_color; }
+	unsigned int fill_color() const { return m_fill_color; }
+	bool do_fill() const { return m_do_fill; }
+	bool print_graduations() const { return m_do_print_graduation; }
+	bool title_bold() const { return m_bold_title; }
+	unsigned int graduation_color() const { return m_graduation_color; }
+	unsigned int background_color() const { return m_background_color; }
+	double graduation_stroke_width() const { return (double)m_graduation_stroke_width; }
+	const Interval& xlim() const { return m_xlim; }
+	const Interval& ylim() const { return m_ylim; }
+	int width() const { return (int)m_width; };
+	int height() const { return (int)m_height; };
+	double graduation_font_size() const { return (double)m_graduation_font_size; }
+	double label_font_size() const;
+	double title_font_size() const;
+	double label_font_size_as_set() const { return (double)m_label_font_size; }
+	double title_font_size_as_set() const { return (double)m_title_font_size; }
+	const std::string& graduation_font() const { return m_graduation_font; }
+	const std::string& xlabel() const { return m_xlabel; }
+	const std::string& ylabel() const { return m_ylabel; }
+	const std::string& title() const { return m_title; }
+	void find_limits(Box& limits, Box& nice_limits) const;
+	void find_unbounded_limits(Box& limits) const;
+	size_t allocated_size() const;
+
+#ifdef CAIRO_HAS_IMAGE_SURFACE
+	void write_png(const std::string& file_name);
+	std::string to_png();
+#endif
+#ifdef CAIRO_HAS_SVG_SURFACE
+	void write_svg(const std::string& file_name);
+	std::string to_svg();
+#endif
+#ifdef CAIRO_HAS_PDF_SURFACE
+	void write_pdf(const std::string& file_name);
+	std::string to_pdf();
+#endif
+
+private:
+	void exec_commands(State&);
+}; // class Figure
+
+} // namespace P1788
+
+#endif /* P1788_FIGURE_HH */