83 lines
3.0 KiB
C++
83 lines
3.0 KiB
C++
// Copyright 2019 The MediaPipe Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef MEDIAPIPE_EXAMPLES_DESKTOP_AUTOFLIP_QUALITY_PIECEWISE_LINEAR_FUNCTION_H_
|
|
#define MEDIAPIPE_EXAMPLES_DESKTOP_AUTOFLIP_QUALITY_PIECEWISE_LINEAR_FUNCTION_H_
|
|
|
|
#include <vector>
|
|
|
|
namespace mediapipe {
|
|
namespace autoflip {
|
|
|
|
// Implementation of piecewise linear functions. The function is specified as a
|
|
// series of points (x1,y1), (x2,y2),..., (xn,yn). It can be constructed
|
|
// programmatically by repeatedly calling the AddPoint(x, y) method.
|
|
class PiecewiseLinearFunction {
|
|
public:
|
|
PiecewiseLinearFunction() {}
|
|
|
|
// Evaluate the function at the specified input. The output
|
|
// saturates at the values of the first and last interpolation
|
|
// points.
|
|
// f(x) = y1 for x <= x1 // Saturate at the lowest value
|
|
// f(x) = yn for x > xn // Saturate at the highest value
|
|
// f(x) = (x-xj)/(xk-xj)*(yk-yj) + yk for xj < x <= xk and k = j+1
|
|
double Evaluate(double input) const;
|
|
|
|
// Adds the given point to the function. Points must be added in
|
|
// non-decreasing x order. Because the points are given in sorted
|
|
// order, this function can be used to construct discontinuous
|
|
// functions. For example, if one defines
|
|
// f.AddPoint(-1.0, 0.0)
|
|
// f.AddPoint( 0.0, 0.0)
|
|
// f.AddPoint( 0.0, 1.0)
|
|
// f.AddPoint( 1.0, 1.0)
|
|
// the result function f is discontinuous at 0.0. By convention,
|
|
// this function will return f.Evaluate(0.0) = 0.0, and
|
|
// f.Evaluate(1e-12) = 1.0. This convention corresponds to the
|
|
// natural behavior of GetIntervalIterator().
|
|
void AddPoint(double x, double y);
|
|
|
|
private:
|
|
struct Point {
|
|
double x;
|
|
double y;
|
|
Point(double X, double Y) : x(X), y(Y) {}
|
|
};
|
|
|
|
// A functor for use with stl algorithms like sort() and lower_bound() that
|
|
// sorts by the point's x value.
|
|
class PointCompare {
|
|
public:
|
|
bool operator()(const Point& p1, const Point& p2) const {
|
|
return p1.x < p2.x;
|
|
}
|
|
};
|
|
|
|
// Returns the iterator, i, closest to points_.begin() such that
|
|
// input <= i->x or it returns points_.end() if input > all x values
|
|
// in points_.
|
|
std::vector<Point>::const_iterator GetIntervalIterator(double input) const;
|
|
|
|
// Given two points p1 and p2 such that p1.x < input and p2.x >= input this
|
|
// returns the linear interpolation of the y value.
|
|
double Interpolate(const Point& p1, const Point& p2, double input) const;
|
|
|
|
std::vector<Point> points_;
|
|
};
|
|
|
|
} // namespace autoflip
|
|
} // namespace mediapipe
|
|
#endif // MEDIAPIPE_EXAMPLES_DESKTOP_AUTOFLIP_QUALITY_PIECEWISE_LINEAR_FUNCTION_H_
|