diff options
Diffstat (limited to 'include/mbgl/style/function/composite_function.hpp')
-rw-r--r-- | include/mbgl/style/function/composite_function.hpp | 109 |
1 files changed, 109 insertions, 0 deletions
diff --git a/include/mbgl/style/function/composite_function.hpp b/include/mbgl/style/function/composite_function.hpp new file mode 100644 index 0000000000..169a455435 --- /dev/null +++ b/include/mbgl/style/function/composite_function.hpp @@ -0,0 +1,109 @@ +#pragma once + +#include <mbgl/style/function/exponential_stops.hpp> +#include <mbgl/style/function/interval_stops.hpp> +#include <mbgl/style/function/categorical_stops.hpp> +#include <mbgl/util/interpolate.hpp> +#include <mbgl/util/range.hpp> +#include <mbgl/util/variant.hpp> + +#include <string> +#include <tuple> + +namespace mbgl { + +class GeometryTileFeature; + +namespace style { + +// A CompositeFunction consists of an outer zoom function whose stop range values are +// "inner" source functions. It provides the GL Native implementation of +// "zoom-and-property" functions from the style spec. + +template <class T> +class CompositeFunction { +public: + using InnerStops = std::conditional_t< + util::Interpolatable<T>, + variant< + ExponentialStops<T>, + IntervalStops<T>, + CategoricalStops<T>>, + variant< + IntervalStops<T>, + CategoricalStops<T>>>; + + using Stops = std::conditional_t< + util::Interpolatable<T>, + variant< + std::map<float, ExponentialStops<T>>, + std::map<float, IntervalStops<T>>, + std::map<float, CategoricalStops<T>>>, + variant< + std::map<float, IntervalStops<T>>, + std::map<float, CategoricalStops<T>>>>; + + CompositeFunction(std::string property_, Stops stops_) + : property(std::move(property_)), + stops(std::move(stops_)) { + } + + std::tuple<Range<float>, Range<InnerStops>> + coveringRanges(float zoom) const { + return stops.match( + [&] (const auto& s) { + assert(!s.empty()); + auto minIt = s.lower_bound(zoom); + auto maxIt = s.upper_bound(zoom); + if (minIt != s.begin()) { + minIt--; + } + return std::make_tuple( + Range<float> { + minIt == s.end() ? s.rbegin()->first : minIt->first, + maxIt == s.end() ? s.rbegin()->first : maxIt->first + }, + Range<InnerStops> { + minIt == s.end() ? s.rbegin()->second : minIt->second, + maxIt == s.end() ? s.rbegin()->second : maxIt->second + } + ); + } + ); + } + + Range<T> evaluate(Range<InnerStops> coveringStops, + const GeometryTileFeature& feature) const { + optional<Value> v = feature.getValue(property); + if (!v) { + return { T(), T() }; + } + auto eval = [&] (const auto& s) { + return s.evaluate(*v); + }; + return Range<T> { + coveringStops.min.match(eval), + coveringStops.max.match(eval) + }; + } + + T evaluate(float zoom, const GeometryTileFeature& feature) const { + std::tuple<Range<float>, Range<InnerStops>> ranges = coveringRanges(zoom); + Range<T> resultRange = evaluate(std::get<1>(ranges), feature); + return util::interpolate( + resultRange.min, + resultRange.max, + util::interpolationFactor(1.0f, std::get<0>(ranges), zoom)); + } + + friend bool operator==(const CompositeFunction& lhs, + const CompositeFunction& rhs) { + return lhs.property == rhs.property && lhs.stops == rhs.stops; + } + + std::string property; + Stops stops; +}; + +} // namespace style +} // namespace mbgl |