#include <path_component.h>

Public Member Functions
	CubicPathComponent ()

	CubicPathComponent (const QuadraticPathComponent &q)

	CubicPathComponent (Point ap1, Point acp1, Point acp2, Point ap2)

Point	Solve (Scalar time) const

Point	SolveDerivative (Scalar time) const

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

std::vector< Point >	Extrema () const

std::vector< QuadraticPathComponent >	ToQuadraticPathComponents (Scalar accuracy) const

CubicPathComponent	Subsegment (Scalar t0, Scalar t1) const

bool	operator== (const CubicPathComponent &other) const

std::optional< Vector2 >	GetStartDirection () const

std::optional< Vector2 >	GetEndDirection () const

Public Attributes
Point	p1

Point	cp1

Point	cp2

Point	p2

Detailed Description

Definition at line 94 of file path_component.h.

Constructor & Destructor Documentation

◆ CubicPathComponent() [1/3]

impeller::CubicPathComponent::CubicPathComponent ( )

inline

Definition at line 104 of file path_component.h.

104 {}

Referenced by Subsegment().

◆ CubicPathComponent() [2/3]

impeller::CubicPathComponent::CubicPathComponent ( const QuadraticPathComponent & q )

inlineexplicit

Definition at line 106 of file path_component.h.

       : p1(q.p1),
         cp1(q.p1 + (q.cp - q.p1) * (2.0 / 3.0)),
         cp2(q.p2 + (q.cp - q.p2) * (2.0 / 3.0)),
         p2(q.p2) {}

◆ CubicPathComponent() [3/3]

impeller::CubicPathComponent::CubicPathComponent	(	Point	ap1,
		Point	acp1,
		Point	acp2,
		Point	ap2
	)

inline

Definition at line 112 of file path_component.h.

113 : p1(ap1), cp1(acp1), cp2(acp2), p2(ap2) {}

Member Function Documentation

◆ AppendPolylinePoints()

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

Definition at line 188 of file path_component.cc.

                                     {
   auto quads = ToQuadraticPathComponents(.1);
   for (const auto& quad : quads) {
     quad.AppendPolylinePoints(scale, points);
   }
 }

References ToQuadraticPathComponents().

Referenced by impeller::testing::TEST().

◆ Extrema()

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

Definition at line 308 of file path_component.cc.

                                                    {
   /*
    *  As described in: https://pomax.github.io/bezierinfo/#extremities
    */
   std::vector<Scalar> values;
  
   CubicPathBoundingPopulateValues(values, p1.x, cp1.x, cp2.x, p2.x);
   CubicPathBoundingPopulateValues(values, p1.y, cp1.y, cp2.y, p2.y);
  
   std::vector<Point> points = {p1, p2};
  
   for (const auto& value : values) {
     points.emplace_back(Solve(value));
   }
  
   return points;
 }

References cp1, cp2, impeller::CubicPathBoundingPopulateValues(), p1, p2, Solve(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::QuadraticPathComponent::Extrema(), impeller::Path::GetMinMaxCoveragePoints(), and impeller::testing::TEST().

◆ GetEndDirection()

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

Definition at line 339 of file path_component.cc.

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

References cp1, cp2, p1, and p2.

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

◆ GetStartDirection()

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

Definition at line 326 of file path_component.cc.

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

References cp1, cp2, p1, and p2.

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

◆ operator==()

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

inline

Definition at line 133 of file path_component.h.

                                                          {
     return p1 == other.p1 && cp1 == other.cp1 && cp2 == other.cp2 &&
            p2 == other.p2;
   }

References cp1, cp2, p1, and p2.

◆ Solve()

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

Definition at line 174 of file path_component.cc.

                                                  {
   return {
       CubicSolve(time, p1.x, cp1.x, cp2.x, p2.x),  // x
       CubicSolve(time, p1.y, cp1.y, cp2.y, p2.y),  // y
   };
 }

References cp1, cp2, impeller::CubicSolve(), p1, p2, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by Extrema(), and Subsegment().

◆ SolveDerivative()

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

Definition at line 181 of file path_component.cc.

                                                            {
   return {
       CubicSolveDerivative(time, p1.x, cp1.x, cp2.x, p2.x),  // x
       CubicSolveDerivative(time, p1.y, cp1.y, cp2.y, p2.y),  // y
   };
 }

References cp1, cp2, impeller::CubicSolveDerivative(), p1, p2, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ Subsegment()

CubicPathComponent impeller::CubicPathComponent::Subsegment	(	Scalar	t0,
		Scalar	t1
	)		const

Definition at line 202 of file path_component.cc.

                                                                             {
   auto p0 = Solve(t0);
   auto p3 = Solve(t1);
   auto d = Lower();
   auto scale = (t1 - t0) * (1.0 / 3.0);
   auto p1 = p0 + scale * d.Solve(t0);
   auto p2 = p3 - scale * d.Solve(t1);
   return CubicPathComponent(p0, p1, p2, p3);
 }

References CubicPathComponent(), p1, p2, and Solve().

Referenced by ToQuadraticPathComponents().

◆ ToQuadraticPathComponents()

std::vector< QuadraticPathComponent > impeller::CubicPathComponent::ToQuadraticPathComponents ( Scalar accuracy ) const

Definition at line 213 of file path_component.cc.

                                                                    {
   std::vector<QuadraticPathComponent> quads;
   // The maximum error, as a vector from the cubic to the best approximating
   // quadratic, is proportional to the third derivative, which is constant
   // across the segment. Thus, the error scales down as the third power of
   // the number of subdivisions. Our strategy then is to subdivide `t` evenly.
   //
   // This is an overestimate of the error because only the component
   // perpendicular to the first derivative is important. But the simplicity is
   // appealing.
  
   // This magic number is the square of 36 / sqrt(3).
   // See: http://caffeineowl.com/graphics/2d/vectorial/cubic2quad01.html
   auto max_hypot2 = 432.0 * accuracy * accuracy;
   auto p1x2 = 3.0 * cp1 - p1;
   auto p2x2 = 3.0 * cp2 - p2;
   auto p = p2x2 - p1x2;
   auto err = p.Dot(p);
   auto quad_count = std::max(1., ceil(pow(err / max_hypot2, 1. / 6.0)));
   quads.reserve(quad_count);
   for (size_t i = 0; i < quad_count; i++) {
     auto t0 = i / quad_count;
     auto t1 = (i + 1) / quad_count;
     auto seg = Subsegment(t0, t1);
     auto p1x2 = 3.0 * seg.cp1 - seg.p1;
     auto p2x2 = 3.0 * seg.cp2 - seg.p2;
     quads.emplace_back(
         QuadraticPathComponent(seg.p1, ((p1x2 + p2x2) / 4.0), seg.p2));
   }
   return quads;
 }