plot_base.h

#pragma once
 
#include <vector>
 
#include <cgv/base/base.h>
#include <cgv/render/attribute_array_binding.h>
#include <cgv/render/color_scale_adapter.h>
#include <cgv/render/drawable.h>
#include <cgv/render/shader_program.h>
#include <cgv/render/vertex_buffer.h>
#include <cgv/render/view.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/media/color.h>
#include <cgv/media/color_scale.h>
#include <cgv/media/color_scheme.h>
#include <cgv/media/font/font.h>
#include <cgv/gui/provider.h>
#include <libs/cgv_gl/rectangle_renderer.h>
 
#include "axis_config.h"
 
#include "lib_begin.h"
 
namespace cgv {
    namespace plot {
 
enum VisualVariable
{
    VV_COLOR,
    VV_OPACITY,
    VV_SIZE
};
 
struct domain_config
{
    bool show_domain;
    bool fill;
    std::string title;
    bool show_title;
    bool show_sub_plot_names;
    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 dim, unsigned nr_attrs);
};
 
enum ChartType
{
    CT_POINT,
    CT_LINE_CHART,
    CT_BAR_CHART
};
 
struct mapped_rgb
{
    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
{
    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) {}
};
 
extern CGV_API void add_mapped_size_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_size& ms, std::string options = "");
extern CGV_API void add_mapped_rgb_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_rgb& ms);
extern CGV_API void add_mapped_rgba_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_rgba& ms);
extern CGV_API void add_mapped_opacity_control(cgv::gui::provider& p, cgv::base::base* bp, const std::string& name, mapped_opacity& ms);
 
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
{
    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];
    bool color_scale_is_bipolar[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;
    static const unsigned color_scale_texture_unit = 0;
    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:
    std::array<std::shared_ptr<cgv::render::device_continuous_color_scale>, MAX_NR_COLOR_MAPPINGS> color_scales;
    cgv::render::color_scale_adapter color_scale_adapter;
    int color_scheme_index[MAX_NR_COLOR_MAPPINGS];
    bool reversed[2] = { false, false };
 
    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();
    vec3 extent;
    void prepare_extents();
    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);
    void update_color_scales();
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_extent_scaling(float x_scale, float y_scale, float z_scale = 0);
    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 set_color_scale(int mapping_index, int color_scheme_index);
    bool set_color_scale(int mapping_index, const std::string& color_scheme_name);
 
    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);
 
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>