Files
MapLibreParticleLab/src/mbgl/style/expression/interpolate.cpp
Thiago Marcos P. Santos d15b9c1f9c [core] Fix performance-unnecessary-value-param errors
As reported by clang-tidy-8.
2020-03-23 12:09:09 +02:00

315 lines
11 KiB
C++

#include <mbgl/style/expression/interpolate.hpp>
#include <mbgl/style/conversion_impl.hpp>
#include <mbgl/util/string.hpp>
namespace mbgl {
namespace style {
namespace expression {
using namespace mbgl::style::conversion;
template <typename T>
class InterpolateImpl : public Interpolate {
public:
InterpolateImpl(const type::Type& type_,
const Interpolator& interpolator_,
std::unique_ptr<Expression> input_,
// NOLINTNEXTLINE(performance-unnecessary-value-param)
std::map<double, std::unique_ptr<Expression>> stops_)
: Interpolate(type_, interpolator_, std::move(input_), std::move(stops_)) {
static_assert(util::Interpolatable<T>::value, "Interpolate expression requires an interpolatable value type.");
}
EvaluationResult evaluate(const EvaluationContext& params) const override {
const EvaluationResult evaluatedInput = input->evaluate(params);
if (!evaluatedInput) {
return evaluatedInput.error();
}
float x = *fromExpressionValue<float>(*evaluatedInput);
if (std::isnan(x)) {
return EvaluationError { "Input is not a number." };
}
if (stops.empty()) {
return EvaluationError { "No stops in exponential curve." };
}
auto it = stops.upper_bound(x);
if (it == stops.end()) {
return stops.rbegin()->second->evaluate(params);
} else if (it == stops.begin()) {
return stops.begin()->second->evaluate(params);
} else {
float t = interpolationFactor({ std::prev(it)->first, it->first }, x);
if (t == 0.0f) {
return std::prev(it)->second->evaluate(params);
}
if (t == 1.0f) {
return it->second->evaluate(params);
}
EvaluationResult lower = std::prev(it)->second->evaluate(params);
if (!lower) {
return lower.error();
}
EvaluationResult upper = it->second->evaluate(params);
if (!upper) {
return upper.error();
}
if (!lower->is<T>()) {
return EvaluationError {
"Expected value to be of type " + toString(valueTypeToExpressionType<T>()) +
", but found " + toString(typeOf(*lower)) + " instead."
};
}
if (!upper->is<T>()) {
return EvaluationError {
"Expected value to be of type " + toString(valueTypeToExpressionType<T>()) +
", but found " + toString(typeOf(*upper)) + " instead."
};
}
return util::interpolate(lower->get<T>(), upper->get<T>(), t);
}
}
};
ParseResult parseInterpolate(const Convertible& value, ParsingContext& ctx) {
assert(isArray(value));
auto length = arrayLength(value);
if (length < 2) {
ctx.error("Expected an interpolation type expression.");
return ParseResult();
}
const Convertible& interp = arrayMember(value, 1);
if (!isArray(interp) || arrayLength(interp) == 0) {
ctx.error("Expected an interpolation type expression.");
return ParseResult();
}
optional<Interpolator> interpolator;
const optional<std::string> interpName = toString(arrayMember(interp, 0));
if (interpName && *interpName == "linear") {
interpolator = {ExponentialInterpolator(1.0)};
} else if (interpName && *interpName == "exponential") {
optional<double> base;
if (arrayLength(interp) == 2) {
base = toDouble(arrayMember(interp, 1));
}
if (!base) {
ctx.error("Exponential interpolation requires a numeric base.", 1, 1);
return ParseResult();
}
interpolator = {ExponentialInterpolator(*base)};
} else if (interpName && *interpName == "cubic-bezier") {
optional<double> x1;
optional<double> y1;
optional<double> x2;
optional<double> y2;
if (arrayLength(interp) == 5) {
x1 = toDouble(arrayMember(interp, 1));
y1 = toDouble(arrayMember(interp, 2));
x2 = toDouble(arrayMember(interp, 3));
y2 = toDouble(arrayMember(interp, 4));
}
if (
!x1 || !y1 || !x2 || !y2 ||
*x1 < 0 || *x1 > 1 ||
*y1 < 0 || *y1 > 1 ||
*x2 < 0 || *x2 > 1 ||
*y2 < 0 || *y2 > 1
) {
ctx.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);
return ParseResult();
}
interpolator = {CubicBezierInterpolator(*x1, *y1, *x2, *y2)};
}
if (!interpolator) {
ctx.error("Unknown interpolation type " + (interpName ? *interpName : ""), 1, 0);
return ParseResult();
}
std::size_t minArgs = 4;
if (length - 1 < minArgs) {
ctx.error("Expected at least 4 arguments, but found only " + util::toString(length - 1) + ".");
return ParseResult();
}
// [interpolation, interp_type, input, 2 * (n pairs)...]
if ((length - 1) % 2 != 0) {
ctx.error("Expected an even number of arguments.");
return ParseResult();
}
ParseResult input = ctx.parse(arrayMember(value, 2), 2, {type::Number});
if (!input) {
return input;
}
std::map<double, std::unique_ptr<Expression>> stops;
optional<type::Type> outputType;
if (ctx.getExpected() && *ctx.getExpected() != type::Value) {
outputType = ctx.getExpected();
}
double previous = - std::numeric_limits<double>::infinity();
for (std::size_t i = 3; i + 1 < length; i += 2) {
const optional<mbgl::Value> labelValue = toValue(arrayMember(value, i));
optional<double> label;
optional<std::string> labelError;
if (labelValue) {
labelValue->match(
[&](uint64_t n) {
if (n > std::numeric_limits<double>::max()) {
label = optional<double>{std::numeric_limits<double>::infinity()};
} else {
label = optional<double>{static_cast<double>(n)};
}
},
[&](int64_t n) {
if (n > std::numeric_limits<double>::max()) {
label = optional<double>{std::numeric_limits<double>::infinity()};
} else {
label = optional<double>{static_cast<double>(n)};
}
},
[&](double n) {
if (n > std::numeric_limits<double>::max()) {
label = optional<double>{std::numeric_limits<double>::infinity()};
} else {
label = optional<double>{n};
}
},
[&](const auto&) {}
);
}
if (!label) {
ctx.error(labelError ? *labelError :
R"(Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.)",
i);
return ParseResult();
}
if (*label <= previous) {
ctx.error(
R"(Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.)",
i
);
return ParseResult();
}
previous = *label;
auto output = ctx.parse(arrayMember(value, i + 1), i + 1, outputType);
if (!output) {
return ParseResult();
}
if (!outputType) {
outputType = (*output)->getType();
}
stops.emplace(*label, std::move(*output));
}
assert(outputType);
return createInterpolate(*outputType,
*interpolator,
std::move(*input),
std::move(stops),
ctx);
}
ParseResult createInterpolate(type::Type type,
Interpolator interpolator,
std::unique_ptr<Expression> input,
std::map<double, std::unique_ptr<Expression>> stops,
ParsingContext& ctx) {
return type.match(
[&](const type::NumberType&) -> ParseResult {
return ParseResult(std::make_unique<InterpolateImpl<double>>(
type, interpolator, std::move(input), std::move(stops)
));
},
[&](const type::ColorType&) -> ParseResult {
return ParseResult(std::make_unique<InterpolateImpl<Color>>(
type, interpolator, std::move(input), std::move(stops)
));
},
[&](const type::Array& arrayType) -> ParseResult {
if (arrayType.itemType != type::Number || !arrayType.N) {
ctx.error("Type " + toString(type) + " is not interpolatable.");
return ParseResult();
}
return ParseResult(std::make_unique<InterpolateImpl<std::vector<Value>>>(
type, interpolator, std::move(input), std::move(stops)
));
},
[&](const auto&) {
ctx.error("Type " + toString(type) + " is not interpolatable.");
return ParseResult();
}
);
}
Interpolate::Interpolate(const type::Type& type_,
Interpolator interpolator_,
std::unique_ptr<Expression> input_,
std::map<double, std::unique_ptr<Expression>> stops_)
: Expression(Kind::Interpolate, type_),
interpolator(std::move(interpolator_)),
input(std::move(input_)),
stops(std::move(stops_)) {
assert(input->getType() == type::Number);
}
std::vector<optional<Value>> Interpolate::possibleOutputs() const {
std::vector<optional<Value>> result;
for (const auto& stop : stops) {
for (auto& output : stop.second->possibleOutputs()) {
result.push_back(std::move(output));
}
}
return result;
}
mbgl::Value Interpolate::serialize() const {
std::vector<mbgl::Value> serialized;
serialized.emplace_back(getOperator());
interpolator.match(
[&](const ExponentialInterpolator& exponential) {
if (exponential.base == 1) {
serialized.emplace_back(std::vector<mbgl::Value>{{ std::string("linear") }});
} else {
serialized.emplace_back(std::vector<mbgl::Value>{{ std::string("exponential"), exponential.base }});
}
},
[&](const CubicBezierInterpolator& cubicBezier) {
static const std::string cubicBezierTag("cubic-bezier");
auto p1 = cubicBezier.ub.getP1();
auto p2 = cubicBezier.ub.getP2();
serialized.emplace_back(std::vector<mbgl::Value>{{ cubicBezierTag, p1.first, p1.second, p2.first, p2.second }});
}
);
serialized.emplace_back(input->serialize());
for (auto& entry : stops) {
serialized.emplace_back(entry.first);
serialized.emplace_back(entry.second->serialize());
};
return serialized;
}
} // namespace expression
} // namespace style
} // namespace mbgl