bezier.h

/*
 * Copyright 2019 Mirko Kokot
 *
 * 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 BEZIER_H
#define BEZIER_H
 
#include <map>
#include <memory>
 
#include "declarations.h"
 
namespace Bezier
{
class Curve
{
public:
  ~Curve() = default;
 
  Curve(Eigen::MatrixX2d points);
 
  Curve(const PointVector& points);
 
  Curve(const Curve& curve);
  Curve(Curve&&) = default;
  Curve& operator=(const Curve&);
  Curve& operator=(Curve&&) = default;
 
  unsigned order() const;
 
  PointVector controlPoints() const;
 
  Point controlPoint(unsigned idx) const;
 
  std::pair<Point, Point> endPoints() const;
 
  PointVector polyline(double flatness = 0.5) const;
 
  double length() const;
 
  double length(double t) const;
 
  double length(double t1, double t2) const;
 
  double iterateByLength(double t, double s) const;
 
  void reverse();
 
  void setControlPoint(unsigned idx, const Point& point);
 
  void manipulateCurvature(double t, const Point& point);
 
  void elevateOrder();
 
  void lowerOrder();
 
  Point valueAt(double t) const;
 
  Eigen::MatrixX2d valueAt(const std::vector<double>& t_vector) const;
 
  double curvatureAt(double t) const;
 
  double curvatureDerivativeAt(double t) const;
 
  Vector tangentAt(double t, bool normalize = true) const;
 
  Vector normalAt(double t, bool normalize = true) const;
 
  const Curve& derivative() const;
 
  const Curve& derivative(unsigned n) const;
 
  Vector derivativeAt(double t) const;
 
  Vector derivativeAt(unsigned n, double t) const;
 
  std::vector<double> roots() const;
 
  std::vector<double> extrema() const;
 
  BoundingBox boundingBox() const;
 
  std::pair<Curve, Curve> splitCurve(double z = 0.5) const;
 
  PointVector intersections(const Curve& curve) const;
 
  double projectPoint(const Point& point) const;
 
  double distance(const Point& point) const;
 
  void applyContinuity(const Curve& source_curve, const std::vector<double>& beta_coeffs);
 
protected:
  Eigen::MatrixX2d control_points_;
 
  inline void resetCache();
 
private:
  unsigned N_{};
 
  using Coeffs = Eigen::MatrixXd;
  using CoeffsMap = std::map<unsigned, Coeffs>;
 
  // private caching
  mutable std::unique_ptr<const Curve> cached_derivative_;    
  mutable std::unique_ptr<std::vector<double>> cached_roots_; 
  mutable std::unique_ptr<BoundingBox> cached_bounding_box_;  
  mutable std::unique_ptr<PointVector> cached_polyline_;      
  mutable double cached_polyline_flatness_{};                 
  mutable std::unique_ptr<Eigen::VectorXd>
      cached_projection_polynomial_part_; 
  mutable Eigen::MatrixXd
      cached_projection_polynomial_derivative_; 
  mutable std::unique_ptr<Eigen::VectorXd> cached_chebyshev_coeffs_;  
  // static caching
  static CoeffsMap bernstein_coeffs_;       
  static CoeffsMap splitting_coeffs_left_;  
  static CoeffsMap splitting_coeffs_right_; 
  static CoeffsMap elevate_order_coeffs_;   
  static CoeffsMap lower_order_coeffs_;     
  static Coeffs bernsteinCoeffs(unsigned n);
  static Coeffs splittingCoeffsLeft(unsigned n, double z = 0.5);
  static Coeffs splittingCoeffsRight(unsigned n, double z = 0.5);
  static Coeffs elevateOrderCoeffs(unsigned n);
  static Coeffs lowerOrderCoeffs(unsigned n);
};
 
} // namespace Bezier
 
#endif // BEZIER_H