transfer_function.h

#pragma once
 
#include <algorithm>
#include <vector>
 
#include <cgv/math/interpolate.h>
#include <cgv/math/fvec.h>
 
#include "color.h"
#include "color_scale.h"
#include "color_scheme.h"
 
#include "lib_begin.h"
 
namespace cgv {
namespace media {
 
class CGV_API transfer_function : public color_scale {
public:
    enum class InterpolationMode {
        kStep,
        kLinear,
        kSmooth
    };
 
    using color_type = cgv::rgb;
    using opacity_type = float;
    using color_point_type = std::pair<float, color_type>;
    using opacity_point_type = std::pair<float, opacity_type>;
 
    transfer_function() {}
 
    transfer_function(std::initializer_list<color_point_type> colors);
 
    transfer_function(std::initializer_list<color_point_type> colors, std::initializer_list<opacity_point_type> opacities);
 
    bool is_opaque() const override {
        return opacity_points_.empty();
    }
 
    bool is_discrete() const override {
        return false;
    }
 
    bool empty() const {
        return color_points_.empty() && opacity_points_.empty();
    }
 
    void clear();
 
    void clear_color_points();
 
    void clear_opacity_points();
 
    void set_color_points(const std::vector<color_point_type>& colors);
 
    void set_color_points_from_scheme(const cgv::media::continuous_color_scheme& scheme, size_t n);
 
    void set_opacity_points(const std::vector<opacity_point_type>& opacities);
 
    void add_color_point(float x, const color_type& color);
 
    void add_opacity_point(float x, float opacity);
 
    bool set_color(size_t index, const color_type& color);
 
    bool set_color_at(float x, const color_type& color);
 
    bool set_opacity(size_t index, const opacity_type& opacity);
 
    bool set_opacity_at(float x, const opacity_type& opacity);
 
    bool remove_color_point(float x);
 
    bool remove_opacity_point(float x);
 
    const size_t get_color_point_count() const {
        return color_points_.size();
    }
 
    const size_t get_opacity_point_count() const {
        return opacity_points_.size();
    }
 
    const std::vector<color_point_type>& get_color_points() const {
        return color_points_;
    }
 
    const std::vector<opacity_point_type>& get_opacity_points() const {
        return opacity_points_;
    }
 
    void set_domain(cgv::vec2 domain) override;
 
    void rescale(cgv::vec2 domain);
 
    float normalize_value(float value) const override;
 
    cgv::rgba map_value(float value) const override;
 
    cgv::rgb get_mapped_color(float value) const override;
 
    float get_mapped_opacity(float value) const override;
 
    std::vector<cgv::rgba> quantize(size_t count) const override;
 
    std::vector<cgv::rgb> quantize_color(size_t count) const;
 
    std::vector<float> quantize_opacity(size_t count) const;
 
    std::vector<float> get_ticks(size_t request_count) const override;
 
    void set_interpolation(InterpolationMode interpolation);
 
    void set_color_interpolation(InterpolationMode interpolation);
 
    InterpolationMode get_color_interpolation() const {
        return color_interpolation_;
    }
 
    void set_opacity_interpolation(InterpolationMode interpolation);
 
    InterpolationMode get_opacity_interpolation() const {
        return opacity_interpolation_;
    }
 
private:
    template<typename value_type>
    typename std::vector<std::pair<float, value_type>>::iterator find_point(std::vector<std::pair<float, value_type>>& points, float x) {
        return std::find_if(points.begin(), points.end(), [&x](const std::pair<float, value_type>& point) { return point.first == x; });
    }
 
    template<typename value_type>
    bool remove_point(std::vector<std::pair<float, value_type>>& points, float x) {
        auto it = find_point(points, x);
        if(it == points.end() || it == points.begin() || it == --points.end())
            return false;
        points.erase(it);
        return true;
    }
 
    template<typename value_type>
    void ensure_control_points_cover_domain(std::vector<std::pair<float, value_type>>& points) {
        if(!points.empty()) {
            cgv::vec2 domain = get_domain();
            if(domain[0] < points.front().first)
                points.insert(points.begin(), { domain[0], points.front().second });
            if(domain[1] > points.back().first)
                points.push_back({ domain[1], points.back().second });
        }
    }
 
    template<typename value_type>
    void sort_points_and_update_domain(std::vector<std::pair<float, value_type>>& points) {
        std::sort(points.begin(), points.end(), [](const auto& lhs, const auto& rhs) { return lhs.first < rhs.first; });
        // Only call modified if this did not already happen in update_domain.
        if(!update_domain())
            modified();
    }
 
    template<typename value_type>
    value_type interpolate_step(const std::vector<std::pair<float, value_type>>& points, float x) const {
        return cgv::math::detail::interpolate_piece(points, x, [](const value_type& a, const value_type& b, float t_local) { return a; });
    }
 
    template<typename value_type>
    std::vector<value_type> interpolate_step_n(const std::vector<std::pair<float, value_type>>& points, size_t n) const {
        return cgv::math::detail::interpolate_n(points, [](const value_type& a, const value_type& b, float t_local) { return a; }, n);
    }
 
    template<typename value_type>
    value_type interpolate(const std::vector<std::pair<float, value_type>>& points, float x, InterpolationMode interpolation) const {
        switch(interpolation) {
        case InterpolationMode::kStep:
            return interpolate_step(points, x);
        case InterpolationMode::kSmooth:
            return cgv::math::interpolate_smooth_cubic(points, x);
        default:
            return cgv::math::interpolate_linear(points, x);
        }
    }
 
    template<typename value_type>
    std::vector<value_type> quantize(const std::vector<std::pair<float, value_type>>& points, size_t n, InterpolationMode interpolation) const {
        switch(interpolation) {
        case InterpolationMode::kStep:
            return interpolate_step_n(points, n);
        case InterpolationMode::kSmooth:
            return cgv::math::interpolate_smooth_cubic_n(points, n);
        default:
            return cgv::math::interpolate_linear_n(points, n);
        }
    }
 
    bool update_domain();
 
    InterpolationMode color_interpolation_ = InterpolationMode::kLinear;
    InterpolationMode opacity_interpolation_ = InterpolationMode::kLinear;
    std::vector<color_point_type> color_points_;
    std::vector<opacity_point_type> opacity_points_;
};
 
} // namespace media
} // namespace cgv
 
#include <cgv/config/lib_end.h>