cgv/plot3d_8cxx_source.html

#include "plot3d.h"

#include <libs/cgv_gl/gl/gl.h>

#include <cgv/math/ftransform.h>


namespace cgv {

    namespace plot {


void plot3d_config::set_colors(const rgb& base_color)

{

    plot_base_config::set_colors(base_color);

    surface_color = 0.1f * rgb(1, 1, 1) + 0.9f * base_color;

}


void plot3d::compute_tick_render_information()

{

    /*

    collect_tick_geometry(0, 1, &domain_min(0), &domain_max(0), &extent(0));

    collect_tick_geometry(0, 2, &domain_min(0), &domain_max(0), &extent(0));

    collect_tick_geometry(1, 0, &domain_min(0), &domain_max(0), &extent(0));

    collect_tick_geometry(1, 2, &domain_min(0), &domain_max(0), &extent(0));

    collect_tick_geometry(2, 0, &domain_min(0), &domain_max(0), &extent(0));

    collect_tick_geometry(2, 1, &domain_min(0), &domain_max(0), &extent(0));

    */

}


plot3d_config::plot3d_config(const std::string& _name) : plot_base_config(_name, 3)

{

    show_points = true;

    show_lines = true;

    show_line_orientation = true;

    show_bars = false;

    samples_per_row = 0;

    show_surface = true;

    wireframe = false;

    surface_color = rgb(0.7f,0.4f,0);

    face_illumination = PFI_PER_FACE;

    bar_percentual_depth = 1.0f;

}


bool plot3d::compute_sample_coordinate_interval(int i, int ai, float& samples_min, float& samples_max)

{

    // compute bounding box

    bool found_sample = false;

    float min_value, max_value;

    for (unsigned j = 0; j < samples[i].size(); ++j) {

        if (found_sample) {

            min_value = std::min(min_value, samples[i][j](ai));

            max_value = std::max(max_value, samples[i][j](ai));

        }

        else {

            min_value = samples[i][j](ai);

            max_value = samples[i][j](ai);

            found_sample = true;

        }

    }

    if (found_sample) {

        samples_min = min_value;

        samples_max = max_value;

        return true;

    }

    return false;

}


plot3d::plot3d(unsigned nr_attributes) : plot_base(3, nr_attributes)

{

    auto& acs = get_domain_config_ptr()->axis_configs;

    acs[0].name = "x"; acs[0].color = rgb(0.4f, 0.2f, 0.2f);

    acs[1].name = "y"; acs[1].color = rgb(0.2f, 0.4f, 0.2f);

    acs[2].name = "z"; acs[2].color = rgb(0.2f, 0.2f, 0.4f);

    for (unsigned ai = 0; ai < nr_attributes; ++ai)

        acs[ai + 3].name = std::string("attribute_") + cgv::utils::to_string(ai);


    brs.culling_mode = cgv::render::CM_FRONTFACE;

    brs.map_color_to_material = cgv::render::CM_COLOR;

    brs.illumination_mode = cgv::render::IM_TWO_SIDED;


    get_domain_config_ptr()->blend_width_in_pixel = 0.0f;


    legend_location[2] = 0.01f;

}


unsigned plot3d::add_sub_plot(const std::string& name)

{

    // determine index of new sub plot

    unsigned i = get_nr_sub_plots();


    // create new config

    if (i == 0)

        configs.push_back(new plot3d_config(name));

    else {

        configs.push_back(new plot3d_config(ref_sub_plot3d_config(i - 1)));

        ref_sub_plot_config(i).name = name;

    }


    // create new point container

    samples.push_back(std::vector<vec3>());

    attribute_source_arrays.push_back(attribute_source_array());

    attribute_source_arrays.back().attribute_sources.push_back(attribute_source(i, 0, 0, 3 * sizeof(float)));

    attribute_source_arrays.back().attribute_sources.push_back(attribute_source(i, 1, 0, 3 * sizeof(float)));

    attribute_source_arrays.back().attribute_sources.push_back(attribute_source(i, 2, 0, 3 * sizeof(float)));


    // return sub plot index

    return i;

}


void plot3d::delete_sub_plot(unsigned i)

{

    delete configs[i];

    configs[i] = 0;

    configs.erase(configs.begin() + i);

    samples.erase(samples.begin() + i);

}


void plot3d::set_samples_per_row(unsigned i, unsigned N)

{

    ref_sub_plot3d_config(i).samples_per_row = N;

}


unsigned plot3d::get_samples_per_row(unsigned i) const

{

    return const_cast<plot3d*>(this)->ref_sub_plot3d_config(i).samples_per_row;

}


plot3d_config& plot3d::ref_sub_plot3d_config(unsigned i)

{

    return static_cast<plot3d_config&>(ref_sub_plot_config(i));

}


std::vector<vec3>& plot3d::ref_sub_plot_samples(unsigned i)

{

    return samples[i];

}


bool plot3d::init(cgv::render::context& ctx)

{

    bool success = true;

    if (!sphere_prog.build_program(ctx, "plot3d_sphere.glpr")) {

        success = false;

        std::cerr << "could not build GLSL program from plot3d_sphere.glpr" << std::endl;

    }

    else

        sphere_prog.allow_context_to_set_color(false);

    if (!stick_prog.build_program(ctx, "plot3d_stick.glpr")) {

        success = false;

        std::cerr << "could not build GLSL program from plot3d_stick.glpr" << std::endl;

    }

    else

        stick_prog.allow_context_to_set_color(false);

    if (!tick_label_prog.build_program(ctx, "plot3d_tick_label.glpr")) {

        success = false;

        std::cerr << "could not build GLSL program from plot3d_tick_label.glpr" << std::endl;

    }

    else

        tick_label_prog.allow_context_to_set_color(false);

    if (!box_prog.build_program(ctx, "plot3d_box.glpr")) {

        std::cerr << "could not build GLSL program from plot3d_box.glpr" << std::endl;

        success = false;

    }

    else

        box_prog.allow_context_to_set_color(false);

    if (!wirebox_prog.build_program(ctx, "plot3d_box_wire.glpr")) {

        success = false;

        std::cerr << "could not build GLSL program from plot3d_box_wire.glpr" << std::endl;

    }

    else

        wirebox_prog.allow_context_to_set_color(false);

    if (!tube_prog.build_program(ctx, "plot3d_tube.glpr", true)) {

        std::cerr << "could not build GLSL program from plot3d_tube.glpr" << std::endl;

        success = false;

    }

    else {

        tube_prog.set_uniform(ctx, "map_color_to_material", 3);

        tube_prog.allow_context_to_set_color(false);

    }


    //if (!surface_prog.is_created()) {

    //  if (!surface_prog.build_program(ctx, "plot3d_surface.glpr")) {

    //      std::cerr << "could not build GLSL program from plot3d_surface.glpr" << std::endl;

    //  }

    //}

    aam_domain.init(ctx);

    cgv::render::ref_box_renderer(ctx, 1);

    cgv::render::ref_cone_renderer(ctx, 1);

    return plot_base::init(ctx);

}


void plot3d::draw_sub_plots(cgv::render::context& ctx)

{

    float rs = 0.2f*get_domain_config_ptr()->reference_size;

    vecn extent = this->extent.to_vec();

    double y_view_angle = 45.0f;

    if (view_ptr)

        y_view_angle = view_ptr->get_y_view_angle();

    float pixel_extent_per_depth = (float)(2.0 * tan(0.5 * 0.0174532925199 * y_view_angle) / ctx.get_height());


    for (unsigned i = 0; i < get_nr_sub_plots(); ++i) {

        size_t count = enable_attributes(ctx, i, samples);

        if (count > 0) {

            const plot3d_config& spc = ref_sub_plot3d_config(i);

            if (spc.show_plot) {

                if (spc.show_points) {

                    set_plot_uniforms(ctx, sphere_prog);

                    set_mapping_uniforms(ctx, sphere_prog);

                    sphere_prog.set_uniform(ctx, "radius_scale", spc.point_size.size * rs);

                    sphere_prog.set_uniform(ctx, "map_color_to_material", 7);

                    sphere_prog.set_uniform(ctx, "blend_width_in_pixel", get_domain_config_ptr()->blend_width_in_pixel);

                    sphere_prog.set_uniform(ctx, "pixel_extent_per_depth", pixel_extent_per_depth);

                    sphere_prog.set_uniform(ctx, "halo_width_in_pixel", 0.0f);

                    sphere_prog.set_uniform(ctx, "halo_color_strength", 1.0f);

                    sphere_prog.set_uniform(ctx, "percentual_halo_width", spc.point_halo_width.size / spc.point_size.size);

                    sphere_prog.set_uniform(ctx, "color_index", spc.point_color.color_idx);

                    sphere_prog.set_uniform(ctx, "secondary_color_index", spc.point_halo_color.color_idx);

                    sphere_prog.set_uniform(ctx, "opacity_index", spc.point_color.opacity_idx);

                    sphere_prog.set_uniform(ctx, "secondary_opacity_index", spc.point_halo_color.opacity_idx);

                    sphere_prog.set_uniform(ctx, "size_index", spc.point_size.size_idx);

                    sphere_prog.set_uniform(ctx, "secondary_size_index", spc.point_halo_width.size_idx);

                    sphere_prog.set_attribute(ctx, sphere_prog.get_color_index(), spc.point_color.color);

                    sphere_prog.set_attribute(ctx, "secondary_color", spc.point_halo_color.color);

                    sphere_prog.set_attribute(ctx, "size", spc.point_size.size);

                    sphere_prog.enable(ctx);

                    draw_sub_plot_samples(int(count), spc);

                    sphere_prog.disable(ctx);

                }

                if (spc.show_bars) {

                    unsigned N = (unsigned)count;

                    unsigned M = (unsigned)count;

                    if (spc.samples_per_row > 0) {

                        N = spc.samples_per_row;

                        M /= spc.samples_per_row;

                    }

                    float box_width = spc.bar_percentual_width.size * extent((spc.bar_coordinate_index + 1) % 3) / N;

                    float box_depth = spc.bar_percentual_depth.size * extent((spc.bar_coordinate_index + 2) % 3) / M;

                    if (spc.bar_outline_width.size > 0) {

                        //glLineWidth(spc.bar_outline_width.size);

                        set_plot_uniforms(ctx, wirebox_prog);

                        set_mapping_uniforms(ctx, wirebox_prog);

                        wirebox_prog.set_uniform(ctx, "box_width", box_width);

                        wirebox_prog.set_uniform(ctx, "box_depth", box_depth);

                        wirebox_prog.set_uniform(ctx, "box_coordinate_index", spc.bar_coordinate_index);

                        wirebox_prog.set_uniform(ctx, "box_base_window", spc.bar_base_window);

                        wirebox_prog.set_uniform(ctx, "color_index", spc.bar_outline_color.color_idx);

                        wirebox_prog.set_uniform(ctx, "secondary_color_index", -1);

                        wirebox_prog.set_uniform(ctx, "opacity_index", spc.bar_outline_color.opacity_idx);

                        wirebox_prog.set_uniform(ctx, "secondary_opacity_index", -1);

                        wirebox_prog.set_uniform(ctx, "size_index", spc.bar_percentual_width.size_idx);

                        wirebox_prog.set_uniform(ctx, "secondary_size_index", spc.bar_percentual_depth.size_idx);

                        wirebox_prog.set_attribute(ctx, wirebox_prog.get_color_index(), spc.bar_outline_color.color);

                        wirebox_prog.enable(ctx);

                        draw_sub_plot_samples(int(count), spc);

                        wirebox_prog.disable(ctx);

                    }

                    set_plot_uniforms(ctx, box_prog);

                    set_mapping_uniforms(ctx, box_prog);

                    box_prog.set_uniform(ctx, "map_color_to_material", 7);

                    box_prog.set_uniform(ctx, "box_width", box_width);

                    box_prog.set_uniform(ctx, "box_depth", box_depth);

                    box_prog.set_uniform(ctx, "box_base_window", spc.bar_base_window);

                    box_prog.set_uniform(ctx, "box_coordinate_index", spc.bar_coordinate_index);

                    box_prog.set_uniform(ctx, "color_index", spc.bar_color.color_idx);

                    box_prog.set_uniform(ctx, "secondary_color_index", -1);

                    box_prog.set_uniform(ctx, "opacity_index", spc.bar_color.opacity_idx);

                    box_prog.set_uniform(ctx, "secondary_opacity_index", -1);

                    box_prog.set_uniform(ctx, "size_index", spc.bar_percentual_width.size_idx);

                    box_prog.set_uniform(ctx, "secondary_size_index", spc.bar_percentual_depth.size_idx);

                    box_prog.set_attribute(ctx, box_prog.get_color_index(), spc.bar_color.color);

                    box_prog.enable(ctx);

                    draw_sub_plot_samples(int(count), spc);

                    box_prog.disable(ctx);

                }

                if (spc.show_sticks) {

                    set_plot_uniforms(ctx, stick_prog);

                    set_mapping_uniforms(ctx, stick_prog);

                    stick_prog.set_uniform(ctx, "radius_scale", 1.0f);

                    stick_prog.set_uniform(ctx, "stick_coordinate_index", spc.stick_coordinate_index);

                    stick_prog.set_uniform(ctx, "stick_base_window", spc.stick_base_window);

                    stick_prog.set_uniform(ctx, "map_color_to_material", 7);

                    stick_prog.set_uniform(ctx, "color_index", spc.stick_color.color_idx);

                    stick_prog.set_uniform(ctx, "secondary_color_index", -1);

                    stick_prog.set_uniform(ctx, "opacity_index", spc.stick_color.opacity_idx);

                    stick_prog.set_uniform(ctx, "secondary_opacity_index", -1);

                    stick_prog.set_uniform(ctx, "size_index", spc.stick_width.size_idx);

                    stick_prog.set_uniform(ctx, "secondary_size_index", -1);

                    stick_prog.set_attribute(ctx, stick_prog.get_color_index(), spc.stick_color.color);

                    stick_prog.set_attribute(ctx, "secondary_color", spc.stick_color.color);

                    stick_prog.set_attribute(ctx, "size", spc.stick_width.size * rs);

                    stick_prog.set_attribute(ctx, "secondary_size", spc.stick_width.size * rs);

                    stick_prog.enable(ctx);

                    draw_sub_plot_samples(int(count), spc);

                    stick_prog.disable(ctx);

                }

                if (spc.show_lines) {

                    set_plot_uniforms(ctx, tube_prog);

                    set_mapping_uniforms(ctx, tube_prog);

                    tube_prog.set_uniform(ctx, "radius_scale", 1.0f);

                    tube_prog.set_uniform(ctx, "map_color_to_material", 7);

                    tube_prog.set_uniform(ctx, "color_index", spc.line_color.color_idx);

                    tube_prog.set_uniform(ctx, "secondary_color_index", -1);

                    tube_prog.set_uniform(ctx, "opacity_index", spc.line_color.opacity_idx);

                    tube_prog.set_uniform(ctx, "secondary_opacity_index", -1);

                    tube_prog.set_uniform(ctx, "size_index", spc.line_width.size_idx);

                    tube_prog.set_uniform(ctx, "secondary_size_index", -1);

                    tube_prog.set_attribute(ctx, tube_prog.get_color_index(), spc.line_color.color);

                    tube_prog.set_attribute(ctx, "size", spc.line_width.size * rs);

                    tube_prog.enable(ctx);

                    draw_sub_plot_samples(int(count), spc, true);

                    tube_prog.disable(ctx);

                }

            }

        }

        disable_attributes(ctx, i);

    }

}


void plot3d::draw_domain(cgv::render::context& ctx)

{

    tick_labels.clear();

    tick_batches.clear();

    const domain_config& dc = *get_domain_config_ptr();

    vecn E = get_extent();

    set_extent(extent.to_vec());

    if (dc.fill) {

        vec3 origin(0.0f);

        cgv::render::box_renderer& br = cgv::render::ref_box_renderer(ctx);

        brs.surface_color = get_domain_config_ptr()->color;

        bool tmp = br.ref_prog().does_context_set_color();

        br.ref_prog().allow_context_to_set_color(false);

        br.set_render_style(brs);

        br.set_position(ctx, origin);

        br.set_extent(ctx, extent);

        br.set_position_is_center(true);

        br.set_color(ctx, dc.color);

        br.render(ctx, 0, 1);

        br.ref_prog().allow_context_to_set_color(tmp);

    }

    // draw axes

    std::vector<vec3> P;

    std::vector<rgb> C;

    std::vector<float> R;

    float rs = get_domain_config_ptr()->reference_size;

    for (unsigned ai = 0; ai < 3; ++ai) {

        int aj = (ai + 1) % 3;

        int ak = (ai + 2) % 3;

        axis_config& ac = get_domain_config_ptr()->axis_configs[ai];

        axis_config& ao = get_domain_config_ptr()->axis_configs[aj];

        axis_config& ap = get_domain_config_ptr()->axis_configs[ak];

        float lw = rs * ac.line_width;

        rgb col = ac.color;

        vec3 D = 0.5f * extent;

        unsigned cnt = 4;

        float c[5][2] = { {-D[aj],-D[ak]}, {D[aj],-D[ak]}, {D[aj],D[ak]}, {-D[aj],D[ak]} };

        // axis line

        if (ao.get_attribute_min() < 0 && ao.get_attribute_max() > 0 &&

            ap.get_attribute_min() < 0 && ap.get_attribute_max() > 0) {

            c[cnt][0] = ao.plot_space_from_attribute_space(0.0f);

            c[cnt][1] = ap.plot_space_from_attribute_space(0.0f);

            ++cnt;

        }

        vec3 p;

        for (unsigned ci = 0; ci < cnt; ++ci) {

            p[ai] = -D[ai];

            p[aj] = c[ci][0];

            p[ak] = c[ci][1];

            P.push_back(p);

            C.push_back(col);

            R.push_back(lw);

            p[ai] = D[ai];

            P.push_back(p);

            C.push_back(col);

            R.push_back(lw);


            for (unsigned ti = 0; ti < 2; ++ti) {

                tick_config& tc = ti == 0 ? ac.primary_ticks : ac.secondary_ticks;

                if (tc.type == TT_NONE)

                    continue;

                tick_batches.push_back(tick_batch_info(ai, aj, ti == 0, 0, (unsigned)tick_labels.size()));

                float min_tick = ac.tick_space_from_attribute_space(ac.get_attribute_min());

                float max_tick = ac.tick_space_from_attribute_space(ac.get_attribute_max());

                int min_i = (int)ceil(min_tick / tc.step - std::numeric_limits<float>::epsilon());

                int max_i = (int)((max_tick - fmod(max_tick, tc.step)) / tc.step);

                // ignore secondary ticks on domain boundary

                if (ti == 1 && min_i * tc.step - min_tick < std::numeric_limits<float>::epsilon())

                    ++min_i;

                if (ti == 1 && max_i * tc.step - max_tick > -std::numeric_limits<float>::epsilon())

                    --max_i;

                float lw = 0.5f * get_domain_config_ptr()->reference_size * tc.line_width;

                float dl = 0.5f * get_domain_config_ptr()->reference_size * tc.length;

                for (int i = min_i; i <= max_i; ++i) {

                    float c_tick = (float)(i * tc.step);

                    float c_attr = ac.attribute_space_from_tick_space(c_tick);

                    std::string label_str;

                    if (tc.label)

                        label_str = cgv::utils::to_string(c_attr);

                    float c_plot = ac.plot_space_from_window_space(ac.window_space_from_tick_space(c_tick));

                    switch (tc.type) {

                    case TT_DASH:

                        p[ai] = c_plot;

                        p[aj] = c[ci][0]-dl;

                        p[ak] = c[ci][1];

                        P.push_back(p);

                        C.push_back(col);

                        R.push_back(lw);

                        p[aj] = c[ci][0]+dl;

                        P.push_back(p);

                        C.push_back(col);

                        R.push_back(lw);

                        if (!label_str.empty())

                            tick_labels.push_back(label_info(p.to_vec(), label_str, ai == 0 ? cgv::render::TA_BOTTOM : cgv::render::TA_LEFT));

                        p[aj] = c[ci][0];

                        p[ak] = c[ci][1]-dl;

                        P.push_back(p);

                        C.push_back(col);

                        R.push_back(lw);

                        p[ak] = c[ci][1]+dl;

                        P.push_back(p);

                        C.push_back(col);

                        R.push_back(lw);

//                      if (!label_str.empty())

//                          tick_labels.push_back(label_info(p.to_vec(), label_str, ai == 0 ? cgv::render::TA_BOTTOM : cgv::render::TA_LEFT));

                        break;

                    case TT_LINE:

                    case TT_PLANE:

                        if (ci < 4) {

                            p[ai] = c_plot;

                            p[aj] = c[ci][0];

                            p[ak] = c[ci][1];

                            if (!label_str.empty())

                                tick_labels.push_back(label_info(p.to_vec(), label_str, ai == 0 ? cgv::render::TA_BOTTOM : cgv::render::TA_LEFT));

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                            p[aj] = c[(ci + 1) % 4][0];

                            p[ak] = c[(ci + 1) % 4][1];

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                        }

                        else {

                            p[ai] = c_plot;

                            p[aj] = c[ci][0];

                            p[ak] = c[ci][1];

                            if (!label_str.empty())

                                tick_labels.push_back(label_info(p.to_vec(), label_str, ai == 0 ? cgv::render::TA_BOTTOM : cgv::render::TA_LEFT));

                            p[ak] = -D[ak];

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                            p[ak] = D[ak];

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                            p[aj] = -D[aj];

                            p[ak] = c[ci][1];

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                            p[aj] = D[aj];

                            P.push_back(p);

                            C.push_back(col);

                            R.push_back(lw);

                        }

                        break;

                    }

                }

                tick_batches.back().label_count = (unsigned)(tick_labels.size() - tick_batches.back().first_label);

            }

        }

    }

    set_extent(E);


    auto& rcr = cgv::render::ref_cone_renderer(ctx);

    rcr.set_render_style(rcrs);

    rcr.enable_attribute_array_manager(ctx, aam_domain);

    rcr.set_position_array(ctx, P);

    rcr.set_color_array(ctx, C);

    rcr.set_radius_array(ctx, R);

    rcr.render(ctx, 0, P.size());

    rcr.disable_attribute_array_manager(ctx, aam_domain);

}


void plot3d::draw_ticks(cgv::render::context& ctx)

{

    if (tick_labels.empty())

        return;

    ctx.enable_font_face(label_font_face, get_domain_config_ptr()->label_font_size);

    for (const auto& tbc : tick_batches) if (tbc.label_count > 0) {

        ctx.set_color(get_domain_config_ptr()->axis_configs[tbc.ai].color);

        for (unsigned i = tbc.first_label; i < tbc.first_label + tbc.label_count; ++i) {

            const label_info& li = tick_labels[i];

            ctx.set_cursor(li.position, li.label, li.align);

            ctx.output_stream() << li.label;

            ctx.output_stream().flush();

        }

    }

}


void plot3d::draw(cgv::render::context& ctx)

{

    prepare_extents();


    GLboolean blend = glIsEnabled(GL_BLEND);

    GLenum blend_src, blend_dst, depth;

    glGetIntegerv(GL_BLEND_DST, reinterpret_cast<GLint*>(&blend_dst));

    glGetIntegerv(GL_BLEND_SRC, reinterpret_cast<GLint*>(&blend_src));

    glGetIntegerv(GL_DEPTH_FUNC, reinterpret_cast<GLint*>(&depth));


    glEnable(GL_BLEND);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    glDepthFunc(GL_LEQUAL);


    ctx.push_modelview_matrix();

    mat4 R;

    orientation.put_homogeneous_matrix(R);

    ctx.mul_modelview_matrix(cgv::math::translate4<float>(center_location) * R);

    if (get_domain_config_ptr()->show_domain) {

        draw_domain(ctx);

        draw_ticks(ctx);

    }

    if (legend_components != LC_HIDDEN)

        draw_legend(ctx);


    draw_sub_plots(ctx);

    ctx.pop_modelview_matrix();


    if (!blend)

        glDisable(GL_BLEND);

    glDepthFunc(depth);

    glBlendFunc(blend_src, blend_dst);

}


void plot3d::clear(cgv::render::context& ctx)

{

    sphere_prog.destruct(ctx);

    box_prog.destruct(ctx);

    wirebox_prog.destruct(ctx);

    stick_prog.destruct(ctx);

    tube_prog.destruct(ctx);

//  surface_prog.destruct(ctx);

    cgv::render::ref_box_renderer(ctx, -1);

    cgv::render::ref_cone_renderer(ctx, -1);

    aam_domain.destruct(ctx);

    plot_base::clear(ctx);

}


void plot3d::create_line_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc)

{

    plot_base::create_line_config_gui(bp, p, pbc);

    plot3d_config& p3bc = reinterpret_cast<plot3d_config&>(pbc);

    p.add_member_control(bp, "show_orientation", p3bc.show_line_orientation, "check");

}


void plot3d::create_bar_config_gui(cgv::base::base* bp, cgv::gui::provider& p, plot_base_config& pbc)

{

    plot_base::create_bar_config_gui(bp, p, pbc);

    plot3d_config& p3bc = reinterpret_cast<plot3d_config&>(pbc);

    add_mapped_size_control(p, bp, "depth", p3bc.bar_percentual_depth, "min=0.01;max=1;log=true;ticks=true");

}


void plot3d::create_config_gui(cgv::base::base* bp, cgv::gui::provider& p, unsigned i)

{

    plot_base::create_config_gui(bp, p, i);

    plot3d_config& pbc = ref_sub_plot3d_config(i);

    bool show = p.begin_tree_node("surface", pbc.show_surface, false, "level=3;w=100;align=' '");

    p.add_member_control(bp, "show", pbc.show_surface, "toggle", "w=50");

    if (show) {

        p.align("\a");

        p.add_view("samples per row", pbc.samples_per_row);

        p.add_member_control(bp, "wireframe", pbc.wireframe, "check");

        p.add_member_control(bp, "color", pbc.surface_color);

        p.add_member_control(bp, "wireframe", pbc.face_illumination, "dropdown", "enums='none,face,vertex'");

        p.align("\b");

        p.end_tree_node(pbc.show_surface);

    }

}


void plot3d::create_gui(cgv::base::base* bp, cgv::gui::provider& p)

{

    p.add_decorator("plot3d", "heading");

    plot_base::create_gui(bp, p);

    if (p.begin_tree_node("rounded cones", rcrs)) {

        p.align("\a");

        p.add_gui("rcrs", rcrs);

        p.align("\b");

        p.end_tree_node(rcrs);

    }

}


    }

}

cgv::base::base
base class for all classes that can be registered with support for dynamic properties (see also secti...
Definition base.h:75

cgv::gui::provider
derive from this class to provide a gui to the current viewer
Definition provider.h:64

cgv::gui::provider::add_gui
bool add_gui(const std::string &label, T &value, const std::string &gui_type="", const std::string &options="")
Add a composed gui of the given gui_type for the given value.
Definition provider.h:247

cgv::gui::provider::add_decorator
cgv::base::base_ptr add_decorator(const std::string &label, const std::string &decorator_type, const std::string &options="", const std::string &align="\n")
add a newly created decorator to the group
Definition provider.cxx:168

cgv::gui::provider::align
void align(const std::string &_align)
send pure alignment information
Definition provider.cxx:36

cgv::gui::provider::begin_tree_node
bool begin_tree_node(const std::string &label, const T &value, bool initial_visibility=false, const std::string &options="", gui_group_ptr ggp=gui_group_ptr())
Begin a sub tree of a tree structured gui.
Definition provider.h:212

cgv::gui::provider::add_member_control
data::ref_ptr< control< T > > add_member_control(cgv::base::base *base_ptr, const std::string &label, T &value, const std::string &gui_type="", const std::string &options="", const std::string &align="\n")
add control with callback to cgv::base::on_set method on cgv::gui::control::value_change
Definition provider.h:137

cgv::gui::provider::end_tree_node
void end_tree_node(const T &value)
template specialization that allows to specify value reference plus node_instance by using the result...
Definition provider.h:222

cgv::gui::provider::add_view
data::ref_ptr< view< T > > add_view(const std::string &label, const T &value, const std::string &gui_type="", const std::string &options="", const std::string &align="\n")
use this to add a new view to the gui with a given value type, gui type and init options
Definition provider.h:112

cgv::math::fmat< float, 4, 4 >

cgv::math::fvec::to_vec
vec< T > to_vec() const
conversion to vector type
Definition fvec.h:730

cgv::math::quaternion::put_homogeneous_matrix
void put_homogeneous_matrix(hmat_type &M) const
compute equivalent homogeneous 4x4 rotation matrix
Definition quaternion.h:154

cgv::math::vec< float >

cgv::media::color< float, cgv::media::RGB >

cgv::media::color::color
color()
standard constructor does not initialize components
Definition color.h:589

cgv::plot::plot3d
The plot3d class draws 2d plots with potentially several sub plots of different plot configuration.
Definition plot3d.h:46

cgv::plot::plot3d::ref_sub_plot_samples
std::vector< vec3 > & ref_sub_plot_samples(unsigned i=0)
return the samples of the i-th sub plot
Definition plot3d.cxx:136

cgv::plot::plot3d::draw
void draw(cgv::render::context &ctx)
overload to draw the content of this drawable
Definition plot3d.cxx:504

cgv::plot::plot3d::compute_tick_render_information
void compute_tick_render_information()
overloaded in derived classes to compute complete tick render information
Definition plot3d.cxx:16

cgv::plot::plot3d::ref_sub_plot3d_config
plot3d_config & ref_sub_plot3d_config(unsigned i=0)
return a reference to the plot3d configuration of the i-th plot
Definition plot3d.cxx:129

cgv::plot::plot3d::init
bool init(cgv::render::context &ctx)
this method is called after creation or recreation of the context, return whether all necessary funct...
Definition plot3d.cxx:142

cgv::plot::plot3d::create_bar_config_gui
void create_bar_config_gui(cgv::base::base *bp, cgv::gui::provider &p, plot_base_config &pbc)
create the gui for a bar subplot
Definition plot3d.cxx:558

cgv::plot::plot3d::clear
void clear(cgv::render::context &ctx)
clear all objects living in the context like textures or display lists
Definition plot3d.cxx:538

cgv::plot::plot3d::create_gui
void create_gui(cgv::base::base *bp, cgv::gui::provider &p)
create a gui for the plot with gui for all configs
Definition plot3d.cxx:582

cgv::plot::plot3d::set_samples_per_row
void set_samples_per_row(unsigned i, unsigned N)
set the number of samples of the i-th sub plot to N
Definition plot3d.cxx:117

cgv::plot::plot3d::delete_sub_plot
void delete_sub_plot(unsigned i)
delete the i-th sub plot
Definition plot3d.cxx:108

cgv::plot::plot3d::get_samples_per_row
unsigned get_samples_per_row(unsigned i) const
return the number of samples per row
Definition plot3d.cxx:123

cgv::plot::plot3d::create_line_config_gui
void create_line_config_gui(cgv::base::base *bp, cgv::gui::provider &p, plot_base_config &pbc)
create the gui for a line subplot
Definition plot3d.cxx:552

cgv::plot::plot3d::plot3d
plot3d(unsigned nr_attributes=0)
construct 3d plot with given number of additional attributes and default parameters
Definition plot3d.cxx:66

cgv::plot::plot3d::add_sub_plot
unsigned add_sub_plot(const std::string &name)
add sub plot and return reference to samples
Definition plot3d.cxx:84

cgv::plot::plot3d::create_config_gui
void create_config_gui(cgv::base::base *bp, cgv::gui::provider &p, unsigned i)
create the gui for a subplot configuration
Definition plot3d.cxx:565

cgv::plot::plot_base
base class for plot2d and plot3d, which can have several sub plots each
Definition plot_base.h:282

cgv::plot::plot_base::create_config_gui
virtual void create_config_gui(cgv::base::base *bp, cgv::gui::provider &p, unsigned i)
create the gui for a subplot configuration
Definition plot_base.cxx:1543

cgv::plot::plot_base::create_bar_config_gui
virtual void create_bar_config_gui(cgv::base::base *bp, cgv::gui::provider &p, plot_base_config &pbc)
create the gui for a bar subplot
Definition plot_base.cxx:1533

cgv::plot::plot_base::create_line_config_gui
virtual void create_line_config_gui(cgv::base::base *bp, cgv::gui::provider &p, plot_base_config &pbc)
create the gui for a line subplot
Definition plot_base.cxx:1518

cgv::plot::plot_base::get_domain_config_ptr
const domain_config * get_domain_config_ptr() const
return const pointer to domain configuration
Definition plot_base.cxx:1180

cgv::plot::plot_base::clear
void clear(cgv::render::context &ctx)
destruct shader programs
Definition plot_base.cxx:1247

cgv::plot::plot_base::get_nr_sub_plots
unsigned get_nr_sub_plots() const
return current number of sub plots
Definition plot_base.cxx:1195

cgv::plot::plot_base::legend_components
LegendComponent legend_components
whether to show legend
Definition plot_base.h:366

cgv::plot::plot_base::attribute_source_arrays
std::vector< attribute_source_array > attribute_source_arrays
attribute sources
Definition plot_base.h:429

cgv::plot::plot_base::get_extent
vecn get_extent() const
query the plot extend in 2D coordinates
Definition plot_base.cxx:958

cgv::plot::plot_base::orientation
quat orientation
orientiation quaternion mapping from domain to world coordinates
Definition plot_base.h:354

cgv::plot::plot_base::set_mapping_uniforms
void set_mapping_uniforms(cgv::render::context &ctx, cgv::render::shader_program &prog)
set the uniforms for defining the mappings to visual variables
Definition plot_base.cxx:395

cgv::plot::plot_base::center_location
vec3 center_location
center location of domain in world coordinates
Definition plot_base.h:356

cgv::plot::plot_base::configs
std::vector< plot_base_config * > configs
store one configuration per sub plot
Definition plot_base.h:348

cgv::plot::plot_base::tick_labels
std::vector< label_info > tick_labels
all tick labels
Definition plot_base.h:319

cgv::plot::plot_base::ref_sub_plot_config
plot_base_config & ref_sub_plot_config(unsigned i)
return a reference to the plot base configuration of the i-th plot
Definition plot_base.cxx:1199

cgv::plot::plot_base::nr_attributes
unsigned nr_attributes
number of additional attributes
Definition plot_base.h:342

cgv::plot::plot_base::prepare_extents
void prepare_extents()
prepare extents for drawing
Definition plot_base.cxx:343

cgv::plot::plot_base::create_gui
virtual void create_gui(cgv::base::base *bp, cgv::gui::provider &p)
create a gui for the plot with gui for all configs
Definition plot_base.cxx:1586

cgv::plot::plot_base::legend_location
vec3 legend_location
center location of legend in domain coordinates
Definition plot_base.h:368

cgv::plot::plot_base::tick_batches
std::vector< tick_batch_info > tick_batches
twice number of axis pairs with index of first tick label and number of tick labels for primary and s...
Definition plot_base.h:321

cgv::plot::plot_base::set_extent
void set_extent(const vecn &new_extent)
set the plot extend in 2D coordinates
Definition plot_base.cxx:966

cgv::plot::plot_base::set_plot_uniforms
void set_plot_uniforms(cgv::render::context &ctx, cgv::render::shader_program &prog)
set the uniforms for plot configurations
Definition plot_base.cxx:374

cgv::plot::plot_base::init
bool init(cgv::render::context &ctx)
build legend prog and create aab
Definition plot_base.cxx:1212

cgv::plot::plot_base::label_font_face
cgv::media::font::font_face_ptr label_font_face
store pointer to label font face
Definition plot_base.h:419

cgv::plot::plot_base::extent
vec3 extent
extents used for drawing current
Definition plot_base.h:437

cgv::render::box_renderer
renderer that supports point splatting
Definition box_renderer.h:34

cgv::render::box_renderer::set_extent
void set_extent(const context &ctx, const T &extent)
specify a single extent for all boxes
Definition box_renderer.h:67

cgv::render::box_renderer::set_position_is_center
void set_position_is_center(bool _position_is_center)
set the flag, whether the position is interpreted as the box center, true by default
Definition box_renderer.cxx:82

cgv::render::context
base class for all drawables, which is independent of the used rendering API.
Definition context.h:621

cgv::render::context::output_stream
virtual std::ostream & output_stream()
returns an output stream whose output is printed at the current cursor location, which is managed by ...
Definition context.cxx:901

cgv::render::context::mul_modelview_matrix
virtual void mul_modelview_matrix(const dmat4 &MV)
multiply given matrix from right to current modelview matrix
Definition context.cxx:1808

cgv::render::context::set_color
virtual void set_color(const rgba &clr)
set the current color
Definition context.cxx:1617

cgv::render::context::get_height
virtual unsigned int get_height() const =0
return the height of the window

cgv::render::context::enable_font_face
virtual void enable_font_face(media::font::font_face_ptr font_face, float font_size)
enable the given font face with the given size in pixels
Definition context.cxx:906

cgv::render::context::set_cursor
virtual void set_cursor(int x, int y)
flush the output_stream and set a new cursor position given in opengl coordinates with (0,...
Definition context.cxx:1959

cgv::render::context::pop_modelview_matrix
void pop_modelview_matrix()
see push_V for an explanation
Definition context.cxx:1814

cgv::render::context::push_modelview_matrix
void push_modelview_matrix()
push the current viewing matrix onto a matrix stack for viewing matrices.
Definition context.cxx:1802

cgv::render::drawable::show
void show()
show the drawable
Definition drawable.cxx:26

cgv::render::renderer::ref_prog
shader_program & ref_prog()
derived renderer classes have access to shader program
Definition renderer.h:75

cgv::render::renderer::set_color
void set_color(const context &ctx, const T &color)
templated method to set the color attribute from a single color of type T
Definition renderer.h:189

cgv::render::renderer::set_render_style
void set_render_style(const render_style &rs)
reference given render style
Definition renderer.cxx:140

cgv::render::renderer::set_position
void set_position(const context &ctx, const T &position)
templated method to set the position attribute from a single position of type T
Definition renderer.h:173

cgv::render::renderer::render
virtual bool render(context &ctx, size_t start, size_t count, bool use_strips=false, bool use_adjacency=false, uint32_t strip_restart_index=-1)
Convenience function that draws vertex or indexed element with this renderer.
Definition renderer.cxx:342

cgv::render::shader_program::enable
bool enable(context &ctx)
enable the shader program
Definition shader_program.cxx:558

cgv::render::shader_program::disable
bool disable(context &ctx)
disable shader program and restore fixed functionality
Definition shader_program.cxx:580

cgv::render::shader_program::set_uniform
bool set_uniform(const context &ctx, const std::string &name, const T &value, bool generate_error=false)
Set the value of a uniform by name, where the type can be any of int, unsigned, float,...
Definition shader_program.h:139

cgv::render::shader_program::destruct
void destruct(const context &ctx)
destruct shader program
Definition shader_program.cxx:670

cgv::render::shader_program::set_attribute
bool set_attribute(const context &ctx, const std::string &name, const T &value)
set constant default value of a vertex attribute by attribute name, if name does not specify an attri...
Definition shader_program.h:188

cgv::render::shader_program::build_program
bool build_program(const context &ctx, const std::string &file_name, bool show_error=false, const shader_define_map &defines=shader_define_map())
successively calls create, attach_program and link.
Definition shader_program.cxx:484

cgv::render::view::get_y_view_angle
double get_y_view_angle() const
query opening angle (degrees) of view in y-direction
Definition view.cxx:63

cgv::render::TA_BOTTOM
@ TA_BOTTOM
center of bottom edge of text bounds
Definition context.h:278

cgv::render::TA_LEFT
@ TA_LEFT
center of left edge of text bounds
Definition context.h:275

cgv::render::ref_cone_renderer
cone_renderer & ref_cone_renderer(context &ctx, int ref_count_change)
reference to a singleton cone renderer that is shared among drawables
Definition cone_renderer.cxx:7

cgv::render::ref_box_renderer
box_renderer & ref_box_renderer(context &ctx, int ref_count_change)
reference to a singleton box renderer that is shared among drawables
Definition box_renderer.cxx:14

cgv::utils::to_string
std::string to_string(const std::string &v, unsigned int w, unsigned int p, bool)
specialization of conversion from string to strings
Definition convert_string.cxx:7

cgv
the cgv namespace
Definition print.h:11

cgv::vecn
cgv::math::vec< float > vecn
declare type of single precision floating point vector with varying dimension
Definition vec.h:1187

cgv::rgb
cgv::media::color< float, cgv::media::RGB > rgb
declare rgb color type with 32 bit components
Definition color.h:853

cgv::vec3
cgv::math::fvec< float, 3 > vec3
declare type of 3d single precision floating point vectors
Definition fvec.h:669

cgv::plot::attribute_source_array
struct that manages attribute sources and corresponding gpu objects per subplot
Definition plot_base.h:252

cgv::plot::attribute_source
store source of a single plot attribute (one coordinate axis or one float attribute)
Definition plot_base.h:228

cgv::plot::domain_config::reference_size
float reference_size
store size of virtual pixel based measurement
Definition plot_base.h:52

cgv::plot::domain_config::axis_configs
std::vector< axis_config > axis_configs
store a vector of axis configurations (2/3 for plot2/3d plus several attribute axes)
Definition plot_base.h:56

cgv::plot::domain_config::color
rgb color
color of the domain fill
Definition plot_base.h:48

cgv::plot::domain_config::blend_width_in_pixel
float blend_width_in_pixel
store blend width in screen pixels used for antialiasing
Definition plot_base.h:54

cgv::plot::plot3d_config
extend common plot configuration with parameters specific to 2d plot
Definition plot3d.h:23

cgv::plot::plot3d_config::surface_color
rgb surface_color
color of faces
Definition plot3d.h:35

cgv::plot::plot3d_config::face_illumination
PlotFaceIllumination face_illumination
how to illuminate the surface
Definition plot3d.h:37

cgv::plot::plot3d_config::samples_per_row
unsigned samples_per_row
if samples per row > 0, the samples are interpreted as regular grid
Definition plot3d.h:29

cgv::plot::plot3d_config::set_colors
void set_colors(const rgb &base_color)
add tube and surface color
Definition plot3d.cxx:9

cgv::plot::plot3d_config::bar_percentual_depth
mapped_size bar_percentual_depth
provide second dimension of bar extend
Definition plot3d.h:27

cgv::plot::plot3d_config::plot3d_config
plot3d_config(const std::string &_name)
construct with default values
Definition plot3d.cxx:28

cgv::plot::plot3d_config::wireframe
bool wireframe
whether to turn on wireframe
Definition plot3d.h:33

cgv::plot::plot3d_config::show_line_orientation
bool show_line_orientation
whether to illustrate line orientation
Definition plot3d.h:25

cgv::plot::plot3d_config::show_surface
bool show_surface
whether to show faces
Definition plot3d.h:31

cgv::plot::plot_base_config
plot independent configuration parameters of one sub plot in a 2d or 3d plot
Definition plot_base.h:130

cgv::plot::plot_base_config::bar_coordinate_index
int bar_coordinate_index
extended bar information
Definition plot_base.h:188

cgv::plot::plot_base_config::set_colors
virtual void set_colors(const rgb &base_color)
set all colors from reference color
Definition plot_base.cxx:84

cgv::plot::plot_base_config::line_width
mapped_size line_width
line width
Definition plot_base.h:166

cgv::plot::plot_base_config::bar_percentual_width
mapped_size bar_percentual_width
percentual width of bar computed assuming a uniform y-sampling distance
Definition plot_base.h:194

cgv::plot::plot_base_config::name
std::string name
name of sub plot
Definition plot_base.h:132

cgv::plot::plot_base_config::stick_base_window
float stick_base_window
base window position of stick
Definition plot_base.h:179

cgv::plot::plot_base_config::show_lines
bool show_lines
whether to connect data points with lines
Definition plot_base.h:164

cgv::plot::plot_base_config::stick_color
mapped_rgba stick_color
color of the stick line
Definition plot_base.h:183

cgv::plot::plot_base_config::show_bars
bool show_bars
whether to show bars
Definition plot_base.h:186

cgv::plot::plot_base_config::bar_outline_width
mapped_size bar_outline_width
line width of bar outlines
Definition plot_base.h:192

cgv::plot::plot_base_config::show_points
bool show_points
whether to show data points
Definition plot_base.h:152

cgv::plot::plot_base_config::stick_width
mapped_size stick_width
line width of stick
Definition plot_base.h:181

cgv::plot::plot_base_config::bar_color
mapped_rgba bar_color
bar fill color
Definition plot_base.h:196

cgv::plot::plot_base_config::point_color
mapped_rgba point_color
point color
Definition plot_base.h:157

cgv::plot::plot_base_config::stick_coordinate_index
int stick_coordinate_index
extended stick information
Definition plot_base.h:177

cgv::plot::plot_base_config::show_plot
bool show_plot
whether to show sub plot
Definition plot_base.h:140

cgv::plot::plot_base_config::show_sticks
bool show_sticks
whether to show straight lines to the bottom of the plot, which are called sticks
Definition plot_base.h:175

cgv::plot::plot_base_config::line_color
mapped_rgba line_color
line color
Definition plot_base.h:168

cgv::plot::plot_base_config::point_halo_width
mapped_size point_halo_width
width of point halo in pixel
Definition plot_base.h:159

cgv::plot::plot_base_config::bar_outline_color
mapped_rgba bar_outline_color
bar outline color
Definition plot_base.h:198

cgv::plot::plot_base_config::point_size
mapped_size point_size
point size in pixels
Definition plot_base.h:154

cgv::plot::plot_base_config::point_halo_color
mapped_rgba point_halo_color
color of point halo
Definition plot_base.h:161

cgv::render::surface_render_style::culling_mode
CullingMode culling_mode
culling mode for point splats, set to CM_OFF in constructor
Definition surface_renderer.h:32

cgv::render::surface_render_style::map_color_to_material
ColorMapping map_color_to_material
material side[s] where color is to be mapped to the diffuse material component, defaults to MS_FRONT_...
Definition surface_renderer.h:36

cgv::render::surface_render_style::illumination_mode
IlluminationMode illumination_mode
illumination mode defaults to IM_ONE_SIDED
Definition surface_renderer.h:34

cgv::render::surface_render_style::surface_color
cgv::media::illum::surface_material::color_type surface_color
default value for color when map color to material is used
Definition surface_renderer.h:28