plot_base.h

#pragma once
 
#include <cgv/base/base.h>
#include <vector>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/render/drawable.h>
#include <cgv/render/attribute_array_binding.h>
#include <cgv/render/vertex_buffer.h>
#include <cgv/render/shader_program.h>
#include <libs/cgv_gl/rectangle_renderer.h>
#include <cgv/media/color.h>
#include <cgv/media/color_scale.h>
#include <cgv/media/font/font.h>
#include <cgv/render/view.h>
#include <cgv/gui/provider.h>
#include "axis_config.h"
 
#include "lib_begin.h"
 
namespace cgv {
        namespace plot {
 
enum VisualVariable
{
        VV_COLOR,
        VV_OPACITY,
        VV_SIZE
};
 
struct domain_config : public cgv::render::render_types
{
        bool show_domain;
        bool fill;
        std::string title;
        vecn title_pos;
        rgb color;
        rgba title_color;
        float reference_size;
        float blend_width_in_pixel;
        std::vector<axis_config> axis_configs;
        unsigned label_font_index;
        float label_font_size;
        cgv::media::font::FontFaceAttributes label_ffa;
        unsigned title_font_index;
        float title_font_size;
        cgv::media::font::FontFaceAttributes title_ffa;
        domain_config(unsigned nr_axes);
};
 
enum ChartType
{
        CT_POINT,
        CT_LINE_CHART,
        CT_BAR_CHART
};
 
struct mapped_rgb : public cgv::render::render_types
{
        rgb color;
        int color_idx;
        mapped_rgb(const rgb& c = rgb(1,1,1)) : color(c), color_idx(-1) {}
};
 
struct mapped_opacity
{
        float opacity;
        int opacity_idx;
        mapped_opacity(float o = 1.0f) : opacity(o), opacity_idx(-1) {}
};
 
struct mapped_size
{
        float size;
        int size_idx;
        mapped_size(float s = 1.0f) : size(s), size_idx(-1) {}
};
 
struct mapped_rgba : public cgv::render::render_types
{
        rgba color;
        int color_idx;
        int opacity_idx;
        mapped_rgba(const rgba& c = rgba(1, 1, 1, 1)) : color(c), color_idx(-1), opacity_idx(-1) {}
 
};
 
enum SubPlotInfluence
{
        SPI_NONE = 0,
        SPI_POINT = 1,
        SPI_POINT_HALO = 2,
        SPI_LINE = 4,
        SPI_LINE_HALO = 8,
        SPI_STICK = 16,
        SPI_BAR = 32,
        SPI_BAR_OUTLINE = 64,
        SPI_ALL = 127
};
 
struct CGV_API plot_base_config : public cgv::render::render_types
{
        std::string name;
 
        size_t begin_sample;
        size_t end_sample;
 
        bool show_plot;
 
        SubPlotInfluence sub_plot_influence;
        mapped_rgb ref_color;
        mapped_opacity ref_opacity;
        mapped_size ref_size;
 
        bool show_points;
        mapped_size point_size;
 
        mapped_rgba point_color;
        mapped_size point_halo_width;
        mapped_rgba point_halo_color;
 
        bool show_lines;
        mapped_size line_width;
        mapped_rgba line_color;
        mapped_size line_halo_width;
        mapped_rgba line_halo_color;
 
        bool show_sticks;
        int stick_coordinate_index;
        float stick_base_window;
        mapped_size stick_width;
        mapped_rgba stick_color;
 
        bool show_bars;
        int bar_coordinate_index;
        float bar_base_window;
        mapped_size bar_outline_width;
        mapped_size bar_percentual_width;
        mapped_rgba bar_color;
        mapped_rgba bar_outline_color;
 
        plot_base_config(const std::string& _name, unsigned dim);
        virtual void configure_chart(ChartType chart_type);
        virtual void set_colors(const rgb& base_color);
        virtual void set_color_indices(int idx);
        virtual void set_opacities(float _opa);
        virtual void set_opacity_indices(int idx);
        virtual void set_sizes(float _size);
        virtual void set_size_indices(int idx);
        virtual ~plot_base_config();
};
 
enum AttributeSource
{
        AS_NONE,
        AS_SAMPLE_CONTAINER,
        AS_POINTER,
        AS_VBO
};
 
struct CGV_API attribute_source
{
        AttributeSource source;
        union {
                int sub_plot_index;                  // index of other subplot or -1 for current subplot
                const float* pointer;                      // pointer to external data
                const cgv::render::vertex_buffer* vbo_ptr; // pointer to vbo
        };
        size_t offset;                           // offset into vbo or coordinate axis into sample container 
        size_t count;
        size_t stride;                           // stride in all representations
        attribute_source();
        attribute_source(int sub_plot_index, size_t ai, size_t _count, size_t _stride);
        attribute_source(const float* _pointer, size_t _count, size_t _stride);
        attribute_source(const cgv::render::vertex_buffer* _vbo_ptr, size_t _offset, size_t _count, size_t _stride);
        attribute_source(const attribute_source& as);
};
 
struct CGV_API attribute_source_array
{
        bool samples_out_of_date;
        bool sources_out_of_date;
        size_t count;
        cgv::render::attribute_array_binding aab;
        cgv::render::vertex_buffer vbo;
        std::vector<attribute_source> attribute_sources;
        attribute_source_array();
};
enum LegendComponent
{
        LC_HIDDEN            =  0,
        LC_PRIMARY_COLOR     =  1,
        LC_SECONDARY_COLOR   =  2,
        LC_PRIMARY_OPACITY   =  4,
        LC_SECONDARY_OPACITY =  8,
        LC_PRIMARY_SIZE      = 16,
        LC_SECONDARY_SIZE    = 32,
        LC_ANY               = 63
};
 
struct sample_access
{
        virtual size_t size(unsigned i) const = 0;
        virtual float operator() (unsigned i, unsigned k, unsigned o) const = 0;
};
 
class CGV_API plot_base : public cgv::render::drawable, virtual public cgv::signal::tacker
{
private:
        cgv::render::shader_program legend_prog;
protected:
        cgv::render::view* view_ptr;
        struct label_info
        {
                vecn position;
                std::string label;
                cgv::render::TextAlignment align;
                float scale;
                label_info(const vecn& _position, const std::string& _label, cgv::render::TextAlignment _align)
                        : position(_position), label(_label), align(_align), scale(1.0f) {}
        };
        struct tick_batch_info
        {
                int ai, aj;
                bool primary;
                unsigned first_vertex;
                unsigned vertex_count;
                unsigned first_label;
                unsigned label_count;
                tick_batch_info(int _ai, int _aj, bool _primary, unsigned _first_vertex = 0, unsigned _first_label = 0);
        };
        std::vector<label_info> tick_labels, legend_tick_labels;
        std::vector<tick_batch_info> tick_batches, legend_tick_batches;
        float layer_depth;
 
        static std::vector<const char*> font_names;
        static std::string font_name_enum_def;
public:
        void ensure_font_names();
protected:
 
        unsigned dim;
        unsigned nr_attributes;
        domain_config dom_cfg;
        domain_config* dom_cfg_ptr;
        std::vector<plot_base_config*> configs;
 
        quat orientation;
        vec3 center_location;
        vec3 world_space_from_plot_space(const vecn& pnt_plot) const;
        vec3 transform_to_world(const vecn& pnt_attr) const;
public:
        LegendComponent legend_components;
        vec3 legend_location;
        vec2 legend_extent;
        int legend_axis;
        rgba legend_color;
 
        ivec4 out_of_range_mode;
        static const unsigned MAX_NR_COLOR_MAPPINGS = 2;
        int color_mapping[MAX_NR_COLOR_MAPPINGS];
        cgv::media::ColorScale color_scale_index[MAX_NR_COLOR_MAPPINGS];
        float color_scale_gamma[MAX_NR_COLOR_MAPPINGS];
        float window_zero_position[MAX_NR_COLOR_MAPPINGS];
        
        static const unsigned MAX_NR_OPACITY_MAPPINGS = 2;
        int opacity_mapping[MAX_NR_OPACITY_MAPPINGS];
        float opacity_gamma[MAX_NR_OPACITY_MAPPINGS];
        bool  opacity_is_bipolar[MAX_NR_OPACITY_MAPPINGS];
        float opacity_window_zero_position[MAX_NR_OPACITY_MAPPINGS];
        float opacity_min[MAX_NR_OPACITY_MAPPINGS];
        float opacity_max[MAX_NR_OPACITY_MAPPINGS];
        
        static const unsigned MAX_NR_SIZE_MAPPINGS = 2;
        int size_mapping[MAX_NR_SIZE_MAPPINGS];
        float size_gamma[MAX_NR_SIZE_MAPPINGS];
        float size_min[MAX_NR_SIZE_MAPPINGS], size_max[MAX_NR_SIZE_MAPPINGS];
protected:
        cgv::media::font::font_ptr label_font;
        cgv::media::font::font_face_ptr label_font_face;
        cgv::media::font::font_ptr title_font;
        cgv::media::font::font_face_ptr title_font_face;
        cgv::render::vertex_buffer vbo_legend;
        cgv::render::attribute_array_binding aab_legend;
        std::vector<attribute_source_array> attribute_source_arrays;
        void on_legend_axis_change(cgv::gui::provider& p, cgv::gui::control<int>& ctrl);
        void on_font_selection();
        void on_font_face_selection();
        void set_plot_uniforms(cgv::render::context& ctx, cgv::render::shader_program& prog);
        void set_mapping_uniforms(cgv::render::context& ctx, cgv::render::shader_program& prog);
private:
        size_t enable_attributes(cgv::render::context& ctx, int i, const sample_access& sa);
protected:
        cgv::render::rectangle_render_style rrs, font_rrs;
        cgv::render::attribute_array_manager aam_legend, aam_legend_ticks, aam_title;
        void draw_rectangles(cgv::render::context& ctx, cgv::render::attribute_array_manager& aam, 
                std::vector<box2>& R, std::vector<rgb>& C, std::vector<float>& D, size_t offset = 0);
        void draw_tick_labels(cgv::render::context& ctx, cgv::render::attribute_array_manager& aam_ticks, 
                std::vector<label_info>& tick_labels, std::vector<tick_batch_info>& tick_batches, float depth);
        size_t enable_attributes(cgv::render::context& ctx, int i, const std::vector<std::vector<vec2>>& samples);
        size_t enable_attributes(cgv::render::context& ctx, int i, const std::vector<std::vector<vec3>>& samples);
        void disable_attributes(cgv::render::context& ctx, int i);
        void update_samples_out_of_date_flag();
        virtual bool compute_sample_coordinate_interval(int i, int ai, float& samples_min, float& samples_max) = 0;
        void draw_sub_plot_samples(int count, const plot_base_config& spc, bool strip = false);
        void draw_title(cgv::render::context& ctx, vec2 pos, float depth, int si = -1);
        void draw_legend(cgv::render::context& ctx, int layer_idx = 0, bool is_first = true, bool* multi_axis_modes = 0);
        bool extract_tick_rectangles_and_tick_labels(
                std::vector<box2>& R, std::vector<rgb>& C, std::vector<float>& D,
                std::vector<label_info>& tick_labels, int ai, int ci, int ti, float he, 
                float z_plot, float plot_scale = 1.0f, vec2 plot_offset = vec2(0.0f,0.0f), float d = 0.0f, bool multi_axis = true);
        void extract_legend_tick_rectangles_and_tick_labels(
                std::vector<box2>& R, std::vector<rgb>& C, std::vector<float>& D,
                std::vector<label_info>& tick_labels, std::vector<tick_batch_info>& tick_batches, float d, 
                bool clear_cache = false, bool is_first = true, bool* multi_axis_modes = 0);
 
public:
        plot_base(unsigned dim, unsigned nr_attributes = 0);
        unsigned get_dim() const { return dim; }
        void set_view_ptr(cgv::render::view* _view_ptr);
        void set_label_font(float font_size, cgv::media::font::FontFaceAttributes ffa = cgv::media::font::FFA_REGULAR, const std::string& font_name = "");
        const domain_config* get_domain_config_ptr() const;
        domain_config* get_domain_config_ptr();
        void set_domain_config_ptr(domain_config* _new_ptr);
 
        const box2 get_domain() const;
        const box3 get_domain3() const;
        void set_domain(const box2& dom);
        void set_domain3(const box3& dom);
        void set_extent(const vecn& new_extent);
        vecn get_extent() const;
        void set_width(float new_width, bool constrained = true);
        void set_height(float new_height, bool constrained = true);
        void set_orientation(const quat& _orientation);
        void place_origin(const vec3& new_origin_location);
        void place_center(const vec3& new_center_location);
        void place_corner(unsigned corner_index, const vec3& new_corner_location);
        vec3 get_origin() const;
        const quat& get_orientation() const;
        const vec3& get_center() const;
        vec3 get_corner(unsigned i) const;
        const vec3 get_axis_direction(unsigned ai) const;
 
        bool determine_axis_extent_from_subplot(unsigned ai, unsigned i, float& sample_min, float& sample_max);
        void adjust_domain_axis_to_data(unsigned ai, bool adjust_min = true, bool adjust_max = true, bool only_visible = true);
        void adjust_domain_to_data(bool only_visible = true);
        void include_axis_to_domain(unsigned ai);
        void adjust_tick_marks(unsigned max_nr_secondary_ticks = 20, bool adjust_to_attribute_ranges = true);
        void adjust_extent_to_domain_aspect_ratio(int preserve_ai = 0);
 
        unsigned get_nr_sub_plots() const;
        virtual unsigned add_sub_plot(const std::string& name) = 0;
        virtual void delete_sub_plot(unsigned i) = 0;
        plot_base_config& ref_sub_plot_config(unsigned i);
        void set_samples_out_of_date(unsigned i);
        void set_sub_plot_colors(unsigned i, const rgb& base_color);
        void set_sub_plot_attribute(unsigned i, unsigned ai, int subplot_index, size_t aj);
        void set_sub_plot_attribute(unsigned i, unsigned ai, const float* _pointer, size_t count, size_t stride);
        void set_sub_plot_attribute(unsigned i, unsigned ai, const cgv::render::vertex_buffer* _vbo_ptr, size_t _offset, size_t _count, size_t _stride);
 
        bool init(cgv::render::context& ctx);
        void clear(cgv::render::context& ctx);
 
protected:
        void update_ref_opacity(unsigned i, cgv::gui::provider& p);
        void update_ref_opacity_index(unsigned i, cgv::gui::provider& p);
        void update_ref_size(unsigned i, cgv::gui::provider& p);
        void update_ref_size_index(unsigned i, cgv::gui::provider& p);
        void update_ref_color(unsigned i, cgv::gui::provider& p);
        void update_ref_color_index(unsigned i, cgv::gui::provider& p);
        void add_mapped_size_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_size& ms, std::string options = "");
        void add_mapped_rgb_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_rgb& ms);
        void add_mapped_rgba_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_rgba& ms);
        void add_mapped_opacity_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_opacity& ms);
 
public:
        virtual void create_plot_gui(cgv::base::base* bp, cgv::gui::provider& p);
        virtual void create_base_config_gui(cgv::base::base* bp, cgv::gui::provider& p, unsigned i);
        virtual void create_point_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc);
        virtual void create_line_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc);
        virtual void create_stick_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc);
        virtual void create_bar_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc);
        virtual void create_config_gui(cgv::base::base* bp, cgv::gui::provider& p, unsigned i);
        virtual void create_gui(cgv::base::base* bp, cgv::gui::provider& p);
};
 
        }
}
 
#include <cgv/config/lib_end.h>