impeller::CubicPathComponent Struct Reference

#include <path_component.h>

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

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
void	ToLinearPathComponents (Scalar scale, const PointProc &proc) const
void	ToLinearPathComponents (Scalar scale, VertexWriter &writer) const
size_t	CountLinearPathComponents (Scalar scale) 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 174 of file path_component.h.

Member Typedef Documentation

PointProc

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

Definition at line 203 of file path_component.h.

Constructor & Destructor Documentation

CubicPathComponent() [1/3]

impeller::CubicPathComponent::CubicPathComponent ( )

inline

Definition at line 184 of file path_component.h.

{}

Referenced by Subsegment().

CubicPathComponent() [2/3]

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

inlineexplicit

Definition at line 186 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 192 of file path_component.h.

      : 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 326 of file path_component.cc.

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

References scale, and ToLinearPathComponents().

Referenced by impeller::Path::CreatePolyline().

CountLinearPathComponents()

size_t impeller::CubicPathComponent::CountLinearPathComponents

(

Scalar

scale

)

const

Definition at line 342 of file path_component.cc.

                                                                       {
  return std::ceilf(ComputeCubicSubdivisions(scale, *this)) + 2;
}

References impeller::ComputeCubicSubdivisions(), and scale.

Referenced by impeller::Path::CountStorage().

Extrema()

std::vector< Point > impeller::CubicPathComponent::Extrema

(

)

const

Definition at line 433 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(), value, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

GetEndDirection()

std::optional< Vector2 > impeller::CubicPathComponent::GetEndDirection

(

)

const

Definition at line 464 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::Path::EndContour().

GetStartDirection()

std::optional< Vector2 > impeller::CubicPathComponent::GetStartDirection

(

)

const

Definition at line 451 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.

operator==()

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

inline

Definition at line 213 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 312 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(), Subsegment(), and ToLinearPathComponents().

SolveDerivative()

Point impeller::CubicPathComponent::SolveDerivative

(

Scalar

time

)

const

Definition at line 319 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 351 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, scale, and Solve().

ToLinearPathComponents() [1/2]

void impeller::CubicPathComponent::ToLinearPathComponents	(	Scalar	scale,
		const PointProc &	proc
	)		const

Definition at line 361 of file path_component.cc.

                                                                             {
  Scalar line_count = std::ceilf(ComputeCubicSubdivisions(scale, *this));
  for (size_t i = 1; i < line_count; i++) {
    proc(Solve(i / line_count));
  }
  proc(p2);
}

References impeller::ComputeCubicSubdivisions(), p2, scale, and Solve().

Referenced by AppendPolylinePoints(), and impeller::Path::WritePolyline().

ToLinearPathComponents() [2/2]

void impeller::CubicPathComponent::ToLinearPathComponents	(	Scalar	scale,
		VertexWriter &	writer
	)		const

Definition at line 333 of file path_component.cc.

                                                                            {
  Scalar line_count = std::ceilf(ComputeCubicSubdivisions(scale, *this));
  for (size_t i = 1; i < line_count; i++) {
    writer.Write(Solve(i / line_count));
  }
  writer.Write(p2);
}

References impeller::ComputeCubicSubdivisions(), p2, scale, Solve(), and impeller::VertexWriter::Write().

Member Data Documentation

cp1

Point impeller::CubicPathComponent::cp1

Definition at line 178 of file path_component.h.

Referenced by impeller::ComputeCubicSubdivisions(), Extrema(), GetEndDirection(), GetStartDirection(), operator==(), Solve(), SolveDerivative(), and impeller::testing::TEST().

cp2

Point impeller::CubicPathComponent::cp2

Definition at line 180 of file path_component.h.

Referenced by impeller::ComputeCubicSubdivisions(), Extrema(), GetEndDirection(), GetStartDirection(), operator==(), Solve(), SolveDerivative(), and impeller::testing::TEST().

p1

Point impeller::CubicPathComponent::p1

Definition at line 176 of file path_component.h.

Referenced by impeller::ComputeCubicSubdivisions(), Extrema(), GetEndDirection(), GetStartDirection(), operator==(), impeller::PathBuilder::Shift(), Solve(), SolveDerivative(), Subsegment(), impeller::testing::TEST(), and impeller::Path::WritePolyline().

p2

Point impeller::CubicPathComponent::p2

Definition at line 182 of file path_component.h.

Referenced by impeller::ComputeCubicSubdivisions(), Extrema(), GetEndDirection(), GetStartDirection(), operator==(), Solve(), SolveDerivative(), Subsegment(), impeller::testing::TEST(), and ToLinearPathComponents().

---

The documentation for this struct was generated from the following files:

• impeller/geometry/path_component.h
• impeller/geometry/path_component.cc