impeller::ConicPathComponent Struct Reference

#include <path_component.h>

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

Public Member Functions
	ConicPathComponent ()
	ConicPathComponent (Point ap1, Point acp, Point ap2, Scalar weight)
Point	Solve (Scalar time) const
void	AppendPolylinePoints (Scalar scale_factor, std::vector< Point > &points) const
void	ToLinearPathComponents (Scalar scale_factor, const PointProc &proc) const
void	ToLinearPathComponents (Scalar scale, VertexWriter &writer) const
size_t	CountLinearPathComponents (Scalar scale) const
std::vector< Point >	Extrema () const
bool	operator== (const ConicPathComponent &other) const
std::optional< Vector2 >	GetStartDirection () const
std::optional< Vector2 >	GetEndDirection () const
std::array< QuadraticPathComponent, 2 >	ToQuadraticPathComponents () const
void	SubdivideToQuadraticPoints (std::array< Point, 5 > &points) const

Public Attributes
Point	p1
Point	cp
Point	p2
Point	weight

Detailed Description

Definition at line 226 of file path_component.h.

Member Typedef Documentation

PointProc

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

Definition at line 255 of file path_component.h.

Constructor & Destructor Documentation

ConicPathComponent() [1/2]

impeller::ConicPathComponent::ConicPathComponent ( )

inline

Definition at line 245 of file path_component.h.

{}

ConicPathComponent() [2/2]

impeller::ConicPathComponent::ConicPathComponent ( Point  ap1, Point  acp, Point  ap2, Scalar  weight  )

inline

Definition at line 247 of file path_component.h.

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

Member Function Documentation

AppendPolylinePoints()

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

Definition at line 343 of file path_component.cc.

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

References ToLinearPathComponents().

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

CountLinearPathComponents()

size_t impeller::ConicPathComponent::CountLinearPathComponents

(

Scalar

scale

)

const

Definition at line 362 of file path_component.cc.

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

References impeller::ComputeConicSubdivisions(), and scale.

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

Extrema()

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

(

)

const

Definition at line 366 of file path_component.cc.

                                                   {
  std::vector<Point> points;
  for (auto quad : ToQuadraticPathComponents()) {
    auto quad_extrema = quad.Extrema();
    points.insert(points.end(), quad_extrema.begin(), quad_extrema.end());
  }
  return points;
}

References ToQuadraticPathComponents().

GetEndDirection()

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

(

)

const

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

GetStartDirection()

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

(

)

const

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

operator==()

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

inline

Definition at line 265 of file path_component.h.

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

References cp, p1, p2, and weight.

Solve()

Point impeller::ConicPathComponent::Solve

(

Scalar

time

)

const

Definition at line 327 of file path_component.cc.

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

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

Referenced by impeller::testing::TEST_P(), and ToLinearPathComponents().

SubdivideToQuadraticPoints()

void impeller::ConicPathComponent::SubdivideToQuadraticPoints

(

std::array< Point, 5 > &

points

)

const

Definition at line 395 of file path_component.cc.

                                      {
  FML_DCHECK(weight.IsFinite() && weight.x > 0 && weight.y > 0);
 
  // Observe that scale will always be smaller than 1 because weight > 0.
  const Scalar scale = 1.0f / (1.0f + weight.x);
 
  // The subdivided control points below are the sums of the following three
  // terms. Because the terms are multiplied by something <1, and the resulting
  // control points lie within the control points of the original then the
  // terms and the sums below will not overflow. Note that weight * scale
  // approaches 1 as weight becomes very large.
  Point tp1 = p1 * scale;
  Point tcp = cp * (weight.x * scale);
  Point tp2 = p2 * scale;
 
  // Calculate the subdivided control points
  Point sub_cp1 = tp1 + tcp;
  Point sub_cp2 = tcp + tp2;
 
  // The middle point shared by the 2 sub-divisions, the interpolation of
  // the original curve at its halfway point.
  Point sub_mid = (tp1 + tcp + tcp + tp2) * 0.5f;
 
  FML_DCHECK(sub_cp1.IsFinite() && sub_mid.IsFinite() && sub_cp2.IsFinite());
 
  points[0] = p1;
  points[1] = sub_cp1;
  points[2] = sub_mid;
  points[3] = sub_cp2;
  points[4] = p2;
 
  // Update w.
  // Currently this method only subdivides a single time directly to 2
  // quadratics, but if we eventually want to keep the weights for further
  // subdivision, this was the code that did it in Skia:
  // sub_w1 = sub_w2 = SkScalarSqrt(SK_ScalarHalf + w * SK_ScalarHalf)
}

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

Referenced by ToQuadraticPathComponents().

ToLinearPathComponents() [1/2]

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

Definition at line 353 of file path_component.cc.

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

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

ToLinearPathComponents() [2/2]

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

Definition at line 334 of file path_component.cc.

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

References impeller::ComputeConicSubdivisions(), p2, and Solve().

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

ToQuadraticPathComponents()

std::array< QuadraticPathComponent, 2 > impeller::ConicPathComponent::ToQuadraticPathComponents

(

)

const

Definition at line 435 of file path_component.cc.

                                                    {
  std::array<Point, 5> points;
  SubdivideToQuadraticPoints(points);
 
  return {
      QuadraticPathComponent(points[0], points[1], points[2]),
      QuadraticPathComponent(points[2], points[3], points[4]),
  };
}

References SubdivideToQuadraticPoints().

Referenced by Extrema().

Member Data Documentation

cp

Point impeller::ConicPathComponent::cp

Definition at line 230 of file path_component.h.

Referenced by impeller::ComputeConicSubdivisions(), GetEndDirection(), GetStartDirection(), operator==(), Solve(), SubdivideToQuadraticPoints(), and impeller::testing::TEST().

p1

Point impeller::ConicPathComponent::p1

Definition at line 228 of file path_component.h.

Referenced by impeller::ComputeConicSubdivisions(), GetEndDirection(), GetStartDirection(), operator==(), impeller::PathBuilder::Shift(), Solve(), SubdivideToQuadraticPoints(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::Path::WritePolyline().

p2

Point impeller::ConicPathComponent::p2

Definition at line 232 of file path_component.h.

Referenced by impeller::ComputeConicSubdivisions(), GetEndDirection(), GetStartDirection(), operator==(), Solve(), SubdivideToQuadraticPoints(), impeller::testing::TEST(), impeller::testing::TEST_P(), and ToLinearPathComponents().

weight

Point impeller::ConicPathComponent::weight

Definition at line 243 of file path_component.h.

Referenced by impeller::ComputeConicSubdivisions(), operator==(), Solve(), SubdivideToQuadraticPoints(), and impeller::testing::TEST().

---

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

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