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 ()

	Path (Path &&other)=default

Path	Clone () const
	Deeply clone this path and all data associated with it. More...

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, Polyline::PointBufferPtr point_buffer=std::make_unique< std::vector< Point >>(), Polyline::ReclaimPointBufferCallback reclaim=nullptr) 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 55 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 148 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum impeller::Path::ComponentType

strong

Enumerator
kLinear
kQuadratic
kCubic
kContour

Definition at line 57 of file path.h.

                            {
     kLinear,
     kQuadratic,
     kCubic,
     kContour,
   };

Constructor & Destructor Documentation

◆ Path() [1/2]

impeller::Path::Path ( )

Definition at line 16 of file path.cc.

            {
   AddContourComponent({});
 };

◆ ~Path()

impeller::Path::~Path ( )

default

◆ Path() [2/2]

impeller::Path::Path ( Path && other )

default

Member Function Documentation

◆ Clone()

Path impeller::Path::Clone ( ) const

Deeply clone this path and all data associated with it.

Definition at line 76 of file path.cc.

                        {
   Path new_path = *this;
   return new_path;
 }

Referenced by impeller::PathBuilder::CopyPath(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ CreatePolyline()

Path::Polyline impeller::Path::CreatePolyline	(	Scalar	scale,
		Polyline::PointBufferPtr	point_buffer = `std::make_unique<std::vector<Point>>()`,
		Polyline::ReclaimPointBufferCallback	reclaim = `nullptr`
	)		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 straight lines.

Definition at line 253 of file path.cc.

                                                           {
   Polyline polyline(std::move(point_buffer), std::move(reclaim));
  
   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 reinterpret_cast<const LinearPathComponent*>(
             &points_[component.index]);
       case ComponentType::kQuadratic:
         return reinterpret_cast<const QuadraticPathComponent*>(
             &points_[component.index]);
       case ComponentType::kCubic:
         return reinterpret_cast<const CubicPathComponent*>(
             &points_[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::vector<PolylineContour::Component> components;
   std::optional<size_t> previous_path_component_index;
   auto end_contour = [&polyline, &previous_path_component_index,
                       &get_path_component, &components]() {
     // 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);
     contour.components = components;
     components.clear();
  
     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:
         components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = false,
         });
         reinterpret_cast<const LinearPathComponent*>(&points_[component.index])
             ->AppendPolylinePoints(*polyline.points);
         previous_path_component_index = component_i;
         break;
       case ComponentType::kQuadratic:
         components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = true,
         });
         reinterpret_cast<const QuadraticPathComponent*>(
             &points_[component.index])
             ->AppendPolylinePoints(scale, *polyline.points);
         previous_path_component_index = component_i;
         break;
       case ComponentType::kCubic:
         components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = true,
         });
         reinterpret_cast<const CubicPathComponent*>(&points_[component.index])
             ->AppendPolylinePoints(scale, *polyline.points);
         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,
                                      .components = components});
  
         polyline.points->push_back(contour.destination);
         break;
     }
   }
   end_contour();
   return polyline;
 }

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

Referenced by impeller::Tessellator::Tessellate(), impeller::Tessellator::TessellateConvex(), 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 129 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,
                          LinearPathComponent(points_[component.index],
                                              points_[component.index + 1]));
         }
         break;
       case ComponentType::kQuadratic:
         if (quad_applier) {
           quad_applier(currentIndex,
                        QuadraticPathComponent(points_[component.index],
                                               points_[component.index + 1],
                                               points_[component.index + 2]));
         }
         break;
       case ComponentType::kCubic:
         if (cubic_applier) {
           cubic_applier(currentIndex,
                         CubicPathComponent(points_[component.index],
                                            points_[component.index + 1],
                                            points_[component.index + 2],
                                            points_[component.index + 3]));
         }
         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 388 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 34 of file path.cc.

                                                                     {
   if (!type.has_value()) {
     return components_.size();
   }
   auto type_value = type.value();
   if (type_value == ComponentType::kContour) {
     return contours_.size();
   }
   size_t count = 0u;
   for (const auto& component : components_) {
     if (component.type == type_value) {
       count++;
     }
   }
   return count;
 }

References kContour.

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

◆ GetContourComponentAtIndex()

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

Definition at line 220 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 203 of file path.cc.

                                                                      {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kCubic) {
     return false;
   }
  
   auto point_index = components_[index].index;
   cubic =
       CubicPathComponent(points_[point_index], points_[point_index + 1],
                          points_[point_index + 2], points_[point_index + 3]);
   return true;
 }

References kCubic.

◆ GetFillType()

FillType impeller::Path::GetFillType ( ) const

Definition at line 55 of file path.cc.

                                  {
   return fill_;
 }

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

◆ GetLinearComponentAtIndex()

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

Definition at line 171 of file path.cc.

                                                                         {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kLinear) {
     return false;
   }
  
   auto point_index = components_[index].index;
   linear = LinearPathComponent(points_[point_index], points_[point_index + 1]);
   return true;
 }

References kLinear.

◆ GetMinMaxCoveragePoints()

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

Definition at line 413 of file path.cc.

                                                                        {
   if (points_.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& component : components_) {
     switch (component.type) {
       case ComponentType::kLinear: {
         auto* linear = reinterpret_cast<const LinearPathComponent*>(
             &points_[component.index]);
         clamp(linear->p1);
         clamp(linear->p2);
         break;
       }
       case ComponentType::kQuadratic:
         for (const auto& extrema :
              reinterpret_cast<const QuadraticPathComponent*>(
                  &points_[component.index])
                  ->Extrema()) {
           clamp(extrema);
         }
         break;
       case ComponentType::kCubic:
         for (const auto& extrema : reinterpret_cast<const CubicPathComponent*>(
                                        &points_[component.index])
                                        ->Extrema()) {
           clamp(extrema);
         }
         break;
       case ComponentType::kContour:
         break;
     }
   }
  
   if (!min.has_value() || !max.has_value()) {
     return std::nullopt;
   }
  
   return std::make_pair(min.value(), max.value());
 }

References impeller::QuadraticPathComponent::Extrema(), impeller::CubicPathComponent::Extrema(), kContour, kCubic, kLinear, and kQuadratic.

◆ GetQuadraticComponentAtIndex()

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

Definition at line 186 of file path.cc.

                                              {
   if (index >= components_.size()) {
     return false;
   }
  
   if (components_[index].type != ComponentType::kQuadratic) {
     return false;
   }
  
   auto point_index = components_[index].index;
   quadratic = QuadraticPathComponent(
       points_[point_index], points_[point_index + 1], points_[point_index + 2]);
   return true;
 }

References kQuadratic.

◆ GetTransformedBoundingBox()

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

Definition at line 404 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 59 of file path.cc.

                           {
   return convexity_ == Convexity::kConvex;
 }

References impeller::kConvex.

Friends And Related Function Documentation

◆ PathBuilder

friend class PathBuilder

friend

Definition at line 185 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