Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw. More...

#include <path.h>

Classes
struct	Polyline

struct	PolylineContour

Public Types
enum	ComponentType { ComponentType::kLinear, ComponentType::kQuadratic, ComponentType::kCubic, ComponentType::kContour }

template<class T >
using	Applier = std::function< void(size_t index, const T &component)>

Public Member Functions
	Path ()

	~Path ()

size_t	GetComponentCount (std::optional< ComponentType > type={}) const

FillType	GetFillType () const

bool	IsConvex () const

void	EnumerateComponents (const Applier< LinearPathComponent > &linear_applier, const Applier< QuadraticPathComponent > &quad_applier, const Applier< CubicPathComponent > &cubic_applier, const Applier< ContourComponent > &contour_applier) const

bool	GetLinearComponentAtIndex (size_t index, LinearPathComponent &linear) const

bool	GetQuadraticComponentAtIndex (size_t index, QuadraticPathComponent &quadratic) const

bool	GetCubicComponentAtIndex (size_t index, CubicPathComponent &cubic) const

bool	GetContourComponentAtIndex (size_t index, ContourComponent &contour) const

Polyline	CreatePolyline (Scalar scale) const

std::optional< Rect >	GetBoundingBox () const

std::optional< Rect >	GetTransformedBoundingBox (const Matrix &transform) const

std::optional< std::pair< Point, Point > >	GetMinMaxCoveragePoints () const

Friends
class	PathBuilder

Detailed Description

Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw.

All shapes supported by Impeller are paths either directly or via approximation (in the case of circles).

Paths are externally immutable once created, Creating paths must be done using a path builder.

Definition at line 54 of file path.h.

Member Typedef Documentation

◆ Applier

template<class T >

using impeller::Path::Applier = std::function<void(size_t index, const T& component)>

Definition at line 103 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum impeller::Path::ComponentType

strong

Enumerator
kLinear
kQuadratic
kCubic
kContour

Definition at line 56 of file path.h.

                            {
     kLinear,
     kQuadratic,
     kCubic,
     kContour,
   };

Constructor & Destructor Documentation

◆ Path()

impeller::Path::Path ( )

Definition at line 14 of file path.cc.

            {
   AddContourComponent({});
 };

◆ ~Path()

impeller::Path::~Path ( )

default

Member Function Documentation

◆ CreatePolyline()

Path::Polyline impeller::Path::CreatePolyline ( Scalar scale ) const

Callers must provide the scale factor for how this path will be transformed.

It is suitable to use the max basis length of the matrix used to transform the path. If the provided scale is 0, curves will revert to lines.

Definition at line 272 of file path.cc.

                                                     {
   Polyline polyline;
  
   std::optional<Point> previous_contour_point;
   auto collect_points = [&polyline, &previous_contour_point](
                             const std::vector<Point>& collection) {
     if (collection.empty()) {
       return;
     }
  
     for (const auto& point : collection) {
       if (previous_contour_point.has_value() &&
           previous_contour_point.value() == point) {
         // Skip over duplicate points in the same contour.
         continue;
       }
       previous_contour_point = point;
       polyline.points.push_back(point);
     }
   };
  
   auto get_path_component = [this](size_t component_i) -> PathComponentVariant {
     if (component_i >= components_.size()) {
       return std::monostate{};
     }
     const auto& component = components_[component_i];
     switch (component.type) {
       case ComponentType::kLinear:
         return &linears_[component.index];
       case ComponentType::kQuadratic:
         return &quads_[component.index];
       case ComponentType::kCubic:
         return &cubics_[component.index];
       case ComponentType::kContour:
         return std::monostate{};
     }
   };
  
   auto compute_contour_start_direction =
       [&get_path_component](size_t current_path_component_index) {
         size_t next_component_index = current_path_component_index + 1;
         while (!std::holds_alternative<std::monostate>(
             get_path_component(next_component_index))) {
           auto next_component = get_path_component(next_component_index);
           auto maybe_vector =
               std::visit(PathComponentStartDirectionVisitor(), next_component);
           if (maybe_vector.has_value()) {
             return maybe_vector.value();
           } else {
             next_component_index++;
           }
         }
         return Vector2(0, -1);
       };
  
   std::optional<size_t> previous_path_component_index;
   auto end_contour = [&polyline, &previous_path_component_index,
                       &get_path_component]() {
     // Whenever a contour has ended, extract the exact end direction from the
     // last component.
     if (polyline.contours.empty()) {
       return;
     }
  
     if (!previous_path_component_index.has_value()) {
       return;
     }
  
     auto& contour = polyline.contours.back();
     contour.end_direction = Vector2(0, 1);
  
     size_t previous_index = previous_path_component_index.value();
     while (!std::holds_alternative<std::monostate>(
         get_path_component(previous_index))) {
       auto previous_component = get_path_component(previous_index);
       auto maybe_vector =
           std::visit(PathComponentEndDirectionVisitor(), previous_component);
       if (maybe_vector.has_value()) {
         contour.end_direction = maybe_vector.value();
         break;
       } else {
         if (previous_index == 0) {
           break;
         }
         previous_index--;
       }
     }
   };
  
   for (size_t component_i = 0; component_i < components_.size();
        component_i++) {
     const auto& component = components_[component_i];
     switch (component.type) {
       case ComponentType::kLinear:
         collect_points(linears_[component.index].CreatePolyline());
         previous_path_component_index = component_i;
         break;
       case ComponentType::kQuadratic:
         collect_points(quads_[component.index].CreatePolyline(scale));
         previous_path_component_index = component_i;
         break;
       case ComponentType::kCubic:
         collect_points(cubics_[component.index].CreatePolyline(scale));
         previous_path_component_index = component_i;
         break;
       case ComponentType::kContour:
         if (component_i == components_.size() - 1) {
           // If the last component is a contour, that means it's an empty
           // contour, so skip it.
           continue;
         }
         end_contour();
  
         Vector2 start_direction = compute_contour_start_direction(component_i);
         const auto& contour = contours_[component.index];
         polyline.contours.push_back({.start_index = polyline.points.size(),
                                      .is_closed = contour.is_closed,
                                      .start_direction = start_direction});
         previous_contour_point = std::nullopt;
         collect_points({contour.destination});
         break;
     }
     end_contour();
   }
   return polyline;
 }

References impeller::Path::Polyline::contours, kContour, kCubic, kLinear, kQuadratic, and impeller::Path::Polyline::points.

Referenced by impeller::Tessellate(), and impeller::testing::TEST().

◆ EnumerateComponents()

void impeller::Path::EnumerateComponents	(	const Applier< LinearPathComponent > &	linear_applier,
		const Applier< QuadraticPathComponent > &	quad_applier,
		const Applier< CubicPathComponent > &	cubic_applier,
		const Applier< ContourComponent > &	contour_applier
	)		const

Definition at line 125 of file path.cc.

                                                             {
   size_t currentIndex = 0;
   for (const auto& component : components_) {
     switch (component.type) {
       case ComponentType::kLinear:
         if (linear_applier) {
           linear_applier(currentIndex, linears_[component.index]);
         }
         break;
       case ComponentType::kQuadratic:
         if (quad_applier) {
           quad_applier(currentIndex, quads_[component.index]);
         }
         break;
       case ComponentType::kCubic:
         if (cubic_applier) {
           cubic_applier(currentIndex, cubics_[component.index]);
         }
         break;
       case ComponentType::kContour:
         if (contour_applier) {
           contour_applier(currentIndex, contours_[component.index]);
         }
         break;
     }
     currentIndex++;
   }
 }

References kContour, kCubic, kLinear, and kQuadratic.

Referenced by impeller::PathBuilder::AddPath(), and impeller::ComputeTessellator::Tessellate().

◆ GetBoundingBox()

std::optional< Rect > impeller::Path::GetBoundingBox ( ) const

Definition at line 399 of file path.cc.

                                              {
   return computed_bounds_;
 }

Referenced by impeller::Canvas::ClipPath(), GetTransformedBoundingBox(), and impeller::testing::TEST().

◆ GetComponentCount()

size_t impeller::Path::GetComponentCount ( std::optional< ComponentType > type = {} ) const

Definition at line 32 of file path.cc.

                                                                     {
   if (type.has_value()) {
     switch (type.value()) {
       case ComponentType::kLinear:
         return linears_.size();
       case ComponentType::kQuadratic:
         return quads_.size();
       case ComponentType::kCubic:
         return cubics_.size();
       case ComponentType::kContour:
         return contours_.size();
     }
   }
   return components_.size();
 }

References kContour, kCubic, kLinear, and kQuadratic.

Referenced by impeller::ComputeTessellator::Tessellate().

◆ GetContourComponentAtIndex()

bool impeller::Path::GetContourComponentAtIndex	(	size_t	index,
		ContourComponent &	contour
	)		const

Definition at line 201 of file path.cc.

                                                                     {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kContour) {
     return false;
   }
  
   move = contours_[components_[index].index];
   return true;
 }

References kContour.

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

◆ GetCubicComponentAtIndex()

bool impeller::Path::GetCubicComponentAtIndex	(	size_t	index,
		CubicPathComponent &	cubic
	)		const

Definition at line 187 of file path.cc.

                                                                      {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kCubic) {
     return false;
   }
  
   cubic = cubics_[components_[index].index];
   return true;
 }

References kCubic.

◆ GetFillType()

FillType impeller::Path::GetFillType ( ) const

Definition at line 52 of file path.cc.

                                  {
   return fill_;
 }

◆ GetLinearComponentAtIndex()

bool impeller::Path::GetLinearComponentAtIndex	(	size_t	index,
		LinearPathComponent &	linear
	)		const

Definition at line 158 of file path.cc.

                                                                         {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kLinear) {
     return false;
   }
  
   linear = linears_[components_[index].index];
   return true;
 }

References kLinear.

◆ GetMinMaxCoveragePoints()

std::optional< std::pair< Point, Point > > impeller::Path::GetMinMaxCoveragePoints ( ) const

Definition at line 424 of file path.cc.

                                                                        {
   if (linears_.empty() && quads_.empty() && cubics_.empty()) {
     return std::nullopt;
   }
  
   std::optional<Point> min, max;
  
   auto clamp = [&min, &max](const Point& point) {
     if (min.has_value()) {
       min = min->Min(point);
     } else {
       min = point;
     }
  
     if (max.has_value()) {
       max = max->Max(point);
     } else {
       max = point;
     }
   };
  
   for (const auto& linear : linears_) {
     clamp(linear.p1);
     clamp(linear.p2);
   }
  
   for (const auto& quad : quads_) {
     for (const Point& point : quad.Extrema()) {
       clamp(point);
     }
   }
  
   for (const auto& cubic : cubics_) {
     for (const Point& point : cubic.Extrema()) {
       clamp(point);
     }
   }
  
   if (!min.has_value() || !max.has_value()) {
     return std::nullopt;
   }
  
   return std::make_pair(min.value(), max.value());
 }

References impeller::LinearPathComponent::p1, and impeller::LinearPathComponent::p2.

◆ GetQuadraticComponentAtIndex()

bool impeller::Path::GetQuadraticComponentAtIndex	(	size_t	index,
		QuadraticPathComponent &	quadratic
	)		const

Definition at line 172 of file path.cc.

                                              {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kQuadratic) {
     return false;
   }
  
   quadratic = quads_[components_[index].index];
   return true;
 }

References kQuadratic.

◆ GetTransformedBoundingBox()

std::optional< Rect > impeller::Path::GetTransformedBoundingBox ( const Matrix & transform ) const

Definition at line 415 of file path.cc.

                                    {
   auto bounds = GetBoundingBox();
   if (!bounds.has_value()) {
     return std::nullopt;
   }
   return bounds->TransformBounds(transform);
 }

References GetBoundingBox().

◆ IsConvex()

bool impeller::Path::IsConvex ( ) const

Definition at line 56 of file path.cc.

                           {
   return convexity_ == Convexity::kConvex;
 }

References impeller::kConvex.

Friends And Related Function Documentation

◆ PathBuilder

friend class PathBuilder

friend

Definition at line 135 of file path.h.

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

impeller/geometry/path.h
impeller/geometry/path.cc

Classes

Public Types

Public Member Functions

Friends