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 <memory>
#include <mutex>
#include <optional>
 
#include "declarations.h"
 
namespace Bezier
{
class Curve
{
public:
  ~Curve() = default;
 
  Curve(Eigen::MatrixX2d points);
 
  Curve(const PointVector& points);
 
  Curve(const Curve& curve);
  Curve(Curve&& curve) noexcept;
  Curve& operator=(const Curve& curve);
  Curve& operator=(Curve&& curve) noexcept;
 
  unsigned order() const;
 
  PointVector controlPoints() const;
 
  Point controlPoint(unsigned idx) const;
 
  std::pair<Point, Point> endPoints() const;
 
  PointVector polyline() const;
 
  PointVector polyline(double flatness) const;
 
  ParamVector polylineParams() const;
 
  ParamVector polylineParams(double flatness) const;
 
  double length() const;
 
  double length(double t) const;
 
  double length(double t1, double t2) const;
 
  double step(double t, double ds) const;
 
  void reverse();
 
  void setControlPoint(unsigned idx, const Point& point);
 
  void raiseOrder();
 
  void lowerOrder();
 
  Point valueAt(double t) const;
 
  Eigen::MatrixX2d valueAt(const ParamVector& t_vector) const;
 
  double curvatureAt(double t) const;
 
  double curvatureDerivativeAt(double t) const;
 
  Vector tangentAt(double t) const;
 
  Vector normalAt(double t) const;
 
  const Curve& derivative() const;
 
  const Curve& derivative(unsigned n) const;
 
  Vector derivativeAt(double t) const;
 
  Vector derivativeAt(unsigned n, double t) const;
 
  ParamVector roots() const;
 
  ParamVector extrema() const;
 
  BoundingBox boundingBox() const;
 
  std::vector<Curve> splitCurve(const ParamVector& t_vector) const;
 
  std::pair<Curve, Curve> splitCurve(double t = 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& curve, const std::vector<double>& beta_coeffs);
 
  static Curve offsetCurve(const Curve& curve, double offset, unsigned order = 0);
 
  static Curve joinCurves(const Curve& curve1, const Curve& curve2, unsigned order = 0);
 
  static Curve fromPolyline(const PointVector& polyline, unsigned order = 0);
 
private:
  void swap(Curve& other) noexcept;
 
  unsigned N_{};
  Eigen::MatrixX2d control_points_;
 
  struct Cache
  {
    Cache() = default;
    Cache(const Cache& other); // deep-copies derivative; rest are value types
    Cache(Cache&&) = default;
    Cache& operator=(const Cache& other);
    Cache& operator=(Cache&&) = default;
 
    std::unique_ptr<const Curve> derivative;                    
    std::optional<ParamVector> roots;                           
    std::optional<BoundingBox> bounding_box;                    
    std::optional<PointVector> polyline;                        
    std::optional<ParamVector> polyline_t;                      
    double polyline_flatness{};                                 
    std::optional<Eigen::VectorXd> projection_polynomial_const; 
    std::optional<Eigen::MatrixX2d> projection_polynomial_der;  
    std::optional<Eigen::VectorXd> chebyshev_polynomial; 
    void clear();
  };
  mutable Cache cache_;
  mutable std::recursive_mutex cache_mutex_;
};
 
} // namespace Bezier
 
#endif // BEZIER_H