#include <path_component.h>

Public Types
using	PointProc = std::function< void(const Point &point)>

Public Member Functions
	QuadraticPathComponent ()

	QuadraticPathComponent (Point ap1, Point acp, Point ap2)

Point	Solve (Scalar time) const

Point	SolveDerivative (Scalar time) const

void	AppendPolylinePoints (Scalar scale_factor, std::vector< Point > &points) const

void	ToLinearPathComponents (Scalar scale_factor, const PointProc &proc) const

std::vector< Point >	Extrema () const

bool	operator== (const QuadraticPathComponent &other) const

std::optional< Vector2 >	GetStartDirection () const

std::optional< Vector2 >	GetEndDirection () const

Public Attributes
Point	p1

Point	cp

Point	p2

Detailed Description

Definition at line 53 of file path_component.h.

Member Typedef Documentation

◆ PointProc

using impeller::QuadraticPathComponent::PointProc = std::function<void(const Point& point)>

Definition at line 83 of file path_component.h.

Constructor & Destructor Documentation

◆ QuadraticPathComponent() [1/2]

impeller::QuadraticPathComponent::QuadraticPathComponent ( )

inline

Definition at line 61 of file path_component.h.

61 {}

◆ QuadraticPathComponent() [2/2]

impeller::QuadraticPathComponent::QuadraticPathComponent	(	Point	ap1,
		Point	acp,
		Point	ap2
	)

inline

Definition at line 63 of file path_component.h.

64 : p1(ap1), cp(acp), p2(ap2) {}

Member Function Documentation

◆ AppendPolylinePoints()

void impeller::QuadraticPathComponent::AppendPolylinePoints	(	Scalar	scale_factor,
		std::vector< Point > &	points
	)		const

Definition at line 106 of file path_component.cc.

                                     {
   ToLinearPathComponents(scale_factor, [&points](const Point& point) {
     points.emplace_back(point);
   });
 }

References ToLinearPathComponents().

◆ Extrema()

std::vector< Point > impeller::QuadraticPathComponent::Extrema ( ) const

Definition at line 157 of file path_component.cc.

                                                        {
   CubicPathComponent elevated(*this);
   return elevated.Extrema();
 }

References impeller::CubicPathComponent::Extrema().

◆ GetEndDirection()

std::optional< Vector2 > impeller::QuadraticPathComponent::GetEndDirection ( ) const

Definition at line 172 of file path_component.cc.

                                                                    {
   if (p2 != cp) {
     return (p2 - cp).Normalize();
   }
   if (p2 != p1) {
     return (p2 - p1).Normalize();
   }
   return std::nullopt;
 }

References cp, p1, and p2.

Referenced by impeller::PathComponentEndDirectionVisitor::operator()().

◆ GetStartDirection()

std::optional< Vector2 > impeller::QuadraticPathComponent::GetStartDirection ( ) const

Definition at line 162 of file path_component.cc.

                                                                      {
   if (p1 != cp) {
     return (p1 - cp).Normalize();
   }
   if (p1 != p2) {
     return (p1 - p2).Normalize();
   }
   return std::nullopt;
 }

References cp, p1, and p2.

Referenced by impeller::PathComponentStartDirectionVisitor::operator()().

◆ operator==()

bool impeller::QuadraticPathComponent::operator== ( const QuadraticPathComponent & other ) const

inline

Definition at line 89 of file path_component.h.

                                                              {
     return p1 == other.p1 && cp == other.cp && p2 == other.p2;
   }

References cp, p1, and p2.

◆ Solve()

Point impeller::QuadraticPathComponent::Solve ( Scalar time ) const

Definition at line 87 of file path_component.cc.

                                                      {
   return {
       QuadraticSolve(time, p1.x, cp.x, p2.x),  // x
       QuadraticSolve(time, p1.y, cp.y, p2.y),  // y
   };
 }

References cp, p1, p2, impeller::QuadraticSolve(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by ToLinearPathComponents().

◆ SolveDerivative()

Point impeller::QuadraticPathComponent::SolveDerivative ( Scalar time ) const

Definition at line 94 of file path_component.cc.

                                                                {
   return {
       QuadraticSolveDerivative(time, p1.x, cp.x, p2.x),  // x
       QuadraticSolveDerivative(time, p1.y, cp.y, p2.y),  // y
   };
 }

References cp, p1, p2, impeller::QuadraticSolveDerivative(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ ToLinearPathComponents()

void impeller::QuadraticPathComponent::ToLinearPathComponents	(	Scalar	scale_factor,
		const PointProc &	proc
	)		const

Definition at line 114 of file path_component.cc.

                                  {
   auto tolerance = kDefaultCurveTolerance / scale_factor;
   auto sqrt_tolerance = sqrt(tolerance);
  
   auto d01 = cp - p1;
   auto d12 = p2 - cp;
   auto dd = d01 - d12;
   auto cross = (p2 - p1).Cross(dd);
   auto x0 = d01.Dot(dd) * 1 / cross;
   auto x2 = d12.Dot(dd) * 1 / cross;
   auto scale = std::abs(cross / (hypot(dd.x, dd.y) * (x2 - x0)));
  
   auto a0 = ApproximateParabolaIntegral(x0);
   auto a2 = ApproximateParabolaIntegral(x2);
   Scalar val = 0.f;
   if (std::isfinite(scale)) {
     auto da = std::abs(a2 - a0);
     auto sqrt_scale = sqrt(scale);
     if ((x0 < 0 && x2 < 0) || (x0 >= 0 && x2 >= 0)) {
       val = da * sqrt_scale;
     } else {
       // cusp case
       auto xmin = sqrt_tolerance / sqrt_scale;
       val = sqrt_tolerance * da / ApproximateParabolaIntegral(xmin);
     }
   }
   auto u0 = ApproximateParabolaIntegral(a0);
   auto u2 = ApproximateParabolaIntegral(a2);
   auto uscale = 1 / (u2 - u0);
  
   auto line_count = std::max(1., ceil(0.5 * val / sqrt_tolerance));
   auto step = 1 / line_count;
   for (size_t i = 1; i < line_count; i += 1) {
     auto u = i * step;
     auto a = a0 + (a2 - a0) * u;
     auto t = (ApproximateParabolaIntegral(a) - u0) * uscale;
     proc(Solve(t));
   }
   proc(p2);
 }