mirror of
https://github.com/SerenityOS/serenity
synced 2026-05-14 19:06:55 +02:00
d569238896
This adds support for dash patterns to Path::stroke_to_fill(). This is used in PDFs, <canvas>, and <svg>. The implementation is based on the <canvas> spec. It seems to do the right thing for PDF files too. (This commit only adds the feature to LibGfx. Future commits will hook this up for PDF, <canvas>, and <svg>.)
1021 lines
38 KiB
C++
1021 lines
38 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Enumerate.h>
|
|
#include <AK/Math.h>
|
|
#include <AK/StringBuilder.h>
|
|
#include <AK/TypeCasts.h>
|
|
#include <LibGfx/BoundingBox.h>
|
|
#include <LibGfx/Font/ScaledFont.h>
|
|
#include <LibGfx/Painter.h>
|
|
#include <LibGfx/Path.h>
|
|
#include <LibGfx/TextLayout.h>
|
|
#include <LibGfx/Vector2.h>
|
|
|
|
namespace Gfx {
|
|
|
|
void Path::approximate_elliptical_arc_with_cubic_beziers(FloatPoint center, FloatSize radii, float x_axis_rotation, float theta, float theta_delta)
|
|
{
|
|
float sin_x_rotation;
|
|
float cos_x_rotation;
|
|
AK::sincos(x_axis_rotation, sin_x_rotation, cos_x_rotation);
|
|
auto arc_point_and_derivative = [&](float t, FloatPoint& point, FloatPoint& derivative) {
|
|
float sin_angle;
|
|
float cos_angle;
|
|
AK::sincos(t, sin_angle, cos_angle);
|
|
point = FloatPoint {
|
|
center.x()
|
|
+ radii.width() * cos_x_rotation * cos_angle
|
|
- radii.height() * sin_x_rotation * sin_angle,
|
|
center.y()
|
|
+ radii.width() * sin_x_rotation * cos_angle
|
|
+ radii.height() * cos_x_rotation * sin_angle,
|
|
};
|
|
derivative = FloatPoint {
|
|
-radii.width() * cos_x_rotation * sin_angle
|
|
- radii.height() * sin_x_rotation * cos_angle,
|
|
-radii.width() * sin_x_rotation * sin_angle
|
|
+ radii.height() * cos_x_rotation * cos_angle,
|
|
};
|
|
};
|
|
auto approximate_arc_between = [&](float start_angle, float end_angle) {
|
|
auto t = AK::tan((end_angle - start_angle) / 2);
|
|
auto alpha = AK::sin(end_angle - start_angle) * ((AK::sqrt(4 + 3 * t * t) - 1) / 3);
|
|
FloatPoint p1, d1;
|
|
FloatPoint p2, d2;
|
|
arc_point_and_derivative(start_angle, p1, d1);
|
|
arc_point_and_derivative(end_angle, p2, d2);
|
|
auto q1 = p1 + d1.scaled(alpha, alpha);
|
|
auto q2 = p2 - d2.scaled(alpha, alpha);
|
|
cubic_bezier_curve_to(q1, q2, p2);
|
|
};
|
|
// FIXME: Come up with a more mathematically sound step size (using some error calculation).
|
|
auto step = theta_delta;
|
|
int step_count = 1;
|
|
while (fabs(step) > AK::Pi<float> / 4) {
|
|
step /= 2;
|
|
step_count *= 2;
|
|
}
|
|
float prev = theta;
|
|
float t = prev + step;
|
|
for (int i = 0; i < step_count; i++, prev = t, t += step)
|
|
approximate_arc_between(prev, t);
|
|
}
|
|
|
|
void Path::elliptical_arc_to(FloatPoint point, FloatSize radii, float x_axis_rotation, bool large_arc, bool sweep)
|
|
{
|
|
auto next_point = point;
|
|
|
|
double rx = radii.width();
|
|
double ry = radii.height();
|
|
|
|
double x_axis_rotation_s;
|
|
double x_axis_rotation_c;
|
|
AK::sincos(static_cast<double>(x_axis_rotation), x_axis_rotation_s, x_axis_rotation_c);
|
|
FloatPoint last_point = this->last_point();
|
|
|
|
// Step 1 of out-of-range radii correction
|
|
if (rx == 0.0 || ry == 0.0) {
|
|
append_segment<PathSegment::LineTo>(next_point);
|
|
return;
|
|
}
|
|
|
|
// Step 2 of out-of-range radii correction
|
|
if (rx < 0)
|
|
rx *= -1.0;
|
|
if (ry < 0)
|
|
ry *= -1.0;
|
|
|
|
// POSSIBLY HACK: Handle the case where both points are the same.
|
|
auto same_endpoints = next_point == last_point;
|
|
if (same_endpoints) {
|
|
if (!large_arc) {
|
|
// Nothing is going to be drawn anyway.
|
|
return;
|
|
}
|
|
|
|
// Move the endpoint by a small amount to avoid division by zero.
|
|
next_point.translate_by(0.01f, 0.01f);
|
|
}
|
|
|
|
// Find (cx, cy), theta_1, theta_delta
|
|
// Step 1: Compute (x1', y1')
|
|
auto x_avg = static_cast<double>(last_point.x() - next_point.x()) / 2.0;
|
|
auto y_avg = static_cast<double>(last_point.y() - next_point.y()) / 2.0;
|
|
auto x1p = x_axis_rotation_c * x_avg + x_axis_rotation_s * y_avg;
|
|
auto y1p = -x_axis_rotation_s * x_avg + x_axis_rotation_c * y_avg;
|
|
|
|
// Step 2: Compute (cx', cy')
|
|
double x1p_sq = x1p * x1p;
|
|
double y1p_sq = y1p * y1p;
|
|
double rx_sq = rx * rx;
|
|
double ry_sq = ry * ry;
|
|
|
|
// Step 3 of out-of-range radii correction
|
|
double lambda = x1p_sq / rx_sq + y1p_sq / ry_sq;
|
|
double multiplier;
|
|
|
|
if (lambda > 1.0) {
|
|
auto lambda_sqrt = AK::sqrt(lambda);
|
|
rx *= lambda_sqrt;
|
|
ry *= lambda_sqrt;
|
|
multiplier = 0.0;
|
|
} else {
|
|
double numerator = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq;
|
|
double denominator = rx_sq * y1p_sq + ry_sq * x1p_sq;
|
|
multiplier = AK::sqrt(AK::max(0., numerator) / denominator);
|
|
}
|
|
|
|
if (large_arc == sweep)
|
|
multiplier *= -1.0;
|
|
|
|
double cxp = multiplier * rx * y1p / ry;
|
|
double cyp = multiplier * -ry * x1p / rx;
|
|
|
|
// Step 3: Compute (cx, cy) from (cx', cy')
|
|
x_avg = (last_point.x() + next_point.x()) / 2.0f;
|
|
y_avg = (last_point.y() + next_point.y()) / 2.0f;
|
|
double cx = x_axis_rotation_c * cxp - x_axis_rotation_s * cyp + x_avg;
|
|
double cy = x_axis_rotation_s * cxp + x_axis_rotation_c * cyp + y_avg;
|
|
|
|
double theta_1 = AK::atan2((y1p - cyp) / ry, (x1p - cxp) / rx);
|
|
double theta_2 = AK::atan2((-y1p - cyp) / ry, (-x1p - cxp) / rx);
|
|
|
|
auto theta_delta = theta_2 - theta_1;
|
|
|
|
if (!sweep && theta_delta > 0.0) {
|
|
theta_delta -= 2 * AK::Pi<double>;
|
|
} else if (sweep && theta_delta < 0) {
|
|
theta_delta += 2 * AK::Pi<double>;
|
|
}
|
|
|
|
approximate_elliptical_arc_with_cubic_beziers(
|
|
{ cx, cy },
|
|
{ rx, ry },
|
|
x_axis_rotation,
|
|
theta_1,
|
|
theta_delta);
|
|
}
|
|
|
|
void Path::quad(FloatQuad const& quad)
|
|
{
|
|
move_to(quad.p1());
|
|
line_to(quad.p2());
|
|
line_to(quad.p3());
|
|
line_to(quad.p4());
|
|
close();
|
|
}
|
|
|
|
void Path::rounded_rect(FloatRect const& rect, CornerRadius top_left, CornerRadius top_right, CornerRadius bottom_right, CornerRadius bottom_left)
|
|
{
|
|
auto x = rect.x();
|
|
auto y = rect.y();
|
|
auto width = rect.width();
|
|
auto height = rect.height();
|
|
|
|
if (top_left)
|
|
move_to({ x + top_left.horizontal_radius, y });
|
|
else
|
|
move_to({ x, y });
|
|
|
|
if (top_right) {
|
|
horizontal_line_to(x + width - top_right.horizontal_radius);
|
|
elliptical_arc_to({ x + width, y + top_right.horizontal_radius }, { top_right.horizontal_radius, top_right.vertical_radius }, 0, false, true);
|
|
} else {
|
|
horizontal_line_to(x + width);
|
|
}
|
|
|
|
if (bottom_right) {
|
|
vertical_line_to(y + height - bottom_right.vertical_radius);
|
|
elliptical_arc_to({ x + width - bottom_right.horizontal_radius, y + height }, { bottom_right.horizontal_radius, bottom_right.vertical_radius }, 0, false, true);
|
|
} else {
|
|
vertical_line_to(y + height);
|
|
}
|
|
|
|
if (bottom_left) {
|
|
horizontal_line_to(x + bottom_left.horizontal_radius);
|
|
elliptical_arc_to({ x, y + height - bottom_left.vertical_radius }, { bottom_left.horizontal_radius, bottom_left.vertical_radius }, 0, false, true);
|
|
} else {
|
|
horizontal_line_to(x);
|
|
}
|
|
|
|
if (top_left) {
|
|
vertical_line_to(y + top_left.vertical_radius);
|
|
elliptical_arc_to({ x + top_left.horizontal_radius, y }, { top_left.horizontal_radius, top_left.vertical_radius }, 0, false, true);
|
|
} else {
|
|
vertical_line_to(y);
|
|
}
|
|
}
|
|
|
|
void Path::text(Utf8View text, Font const& font)
|
|
{
|
|
if (!is<ScaledFont>(font)) {
|
|
// FIXME: This API only accepts Gfx::Font for ease of use.
|
|
dbgln("Cannot path-ify bitmap fonts!");
|
|
return;
|
|
}
|
|
|
|
auto& scaled_font = static_cast<ScaledFont const&>(font);
|
|
for_each_glyph_position(
|
|
last_point(), text, scaled_font, [&](DrawGlyphOrEmoji glyph_or_emoji) {
|
|
if (glyph_or_emoji.has<DrawGlyph>()) {
|
|
auto& glyph = glyph_or_emoji.get<DrawGlyph>();
|
|
move_to(glyph.position);
|
|
auto glyph_id = scaled_font.glyph_id_for_code_point(glyph.code_point);
|
|
scaled_font.append_glyph_path_to(*this, glyph_id);
|
|
}
|
|
},
|
|
IncludeLeftBearing::Yes);
|
|
}
|
|
|
|
Path Path::place_text_along(Utf8View text, Font const& font) const
|
|
{
|
|
if (!is<ScaledFont>(font)) {
|
|
// FIXME: This API only accepts Gfx::Font for ease of use.
|
|
dbgln("Cannot path-ify bitmap fonts!");
|
|
return {};
|
|
}
|
|
|
|
auto lines = split_lines();
|
|
auto next_point_for_offset = [&, line_index = 0U, distance_along_path = 0.0f, last_line_length = 0.0f](float offset) mutable -> Optional<FloatPoint> {
|
|
while (line_index < lines.size() && offset > distance_along_path) {
|
|
last_line_length = lines[line_index++].length();
|
|
distance_along_path += last_line_length;
|
|
}
|
|
if (offset > distance_along_path)
|
|
return {};
|
|
if (last_line_length > 1) {
|
|
// If the last line segment was fairly long, compute the point in the line.
|
|
float p = (last_line_length + offset - distance_along_path) / last_line_length;
|
|
auto current_line = lines[line_index - 1];
|
|
return current_line.a() + (current_line.b() - current_line.a()).scaled(p);
|
|
}
|
|
if (line_index >= lines.size())
|
|
return {};
|
|
return lines[line_index].a();
|
|
};
|
|
|
|
auto& scaled_font = static_cast<Gfx::ScaledFont const&>(font);
|
|
Gfx::Path result_path;
|
|
Gfx::for_each_glyph_position(
|
|
{}, text, font, [&](Gfx::DrawGlyphOrEmoji glyph_or_emoji) {
|
|
auto* glyph = glyph_or_emoji.get_pointer<Gfx::DrawGlyph>();
|
|
if (!glyph)
|
|
return;
|
|
auto offset = glyph->position.x();
|
|
auto width = font.glyph_width(glyph->code_point);
|
|
auto start = next_point_for_offset(offset);
|
|
if (!start.has_value())
|
|
return;
|
|
auto end = next_point_for_offset(offset + width);
|
|
if (!end.has_value())
|
|
return;
|
|
// Find the angle between the start and end points on the path.
|
|
auto delta = *end - *start;
|
|
auto angle = AK::atan2(delta.y(), delta.x());
|
|
Gfx::Path glyph_path;
|
|
// Rotate the glyph then move it to start point.
|
|
auto glyph_id = scaled_font.glyph_id_for_code_point(glyph->code_point);
|
|
scaled_font.append_glyph_path_to(glyph_path, glyph_id);
|
|
auto transform = Gfx::AffineTransform {}
|
|
.translate(*start)
|
|
.multiply(Gfx::AffineTransform {}.rotate_radians(angle))
|
|
.multiply(Gfx::AffineTransform {}.translate({ 0, -scaled_font.pixel_metrics().ascent }));
|
|
glyph_path = glyph_path.copy_transformed(transform);
|
|
result_path.append_path(glyph_path);
|
|
},
|
|
Gfx::IncludeLeftBearing::Yes);
|
|
return result_path;
|
|
}
|
|
|
|
void Path::close()
|
|
{
|
|
// If there's no `moveto` starting this subpath assume the start is (0, 0).
|
|
FloatPoint first_point_in_subpath = { 0, 0 };
|
|
for (auto it = end(); it-- != begin();) {
|
|
auto segment = *it;
|
|
if (segment.command() == PathSegment::MoveTo) {
|
|
first_point_in_subpath = segment.point();
|
|
break;
|
|
}
|
|
}
|
|
if (first_point_in_subpath != last_point())
|
|
line_to(first_point_in_subpath);
|
|
append_segment<PathSegment::ClosePath>();
|
|
}
|
|
|
|
void Path::close_all_subpaths()
|
|
{
|
|
// This is only called before filling, not before stroking, so this doesn't have to insert ClosePath segments.
|
|
auto it = begin();
|
|
// Note: Get the end outside the loop as closing subpaths will move the end.
|
|
auto end = this->end();
|
|
while (it < end) {
|
|
// If there's no `moveto` starting this subpath assume the start is (0, 0).
|
|
FloatPoint first_point_in_subpath = { 0, 0 };
|
|
auto segment = *it;
|
|
if (segment.command() == PathSegment::MoveTo) {
|
|
first_point_in_subpath = segment.point();
|
|
++it;
|
|
}
|
|
// Find the end of the current subpath.
|
|
FloatPoint cursor = first_point_in_subpath;
|
|
for (; it < end; ++it) {
|
|
auto segment = *it;
|
|
if (segment.command() == PathSegment::ClosePath)
|
|
continue;
|
|
if (segment.command() == PathSegment::MoveTo)
|
|
break;
|
|
cursor = segment.point();
|
|
}
|
|
// Close the subpath.
|
|
if (first_point_in_subpath != cursor) {
|
|
move_to(cursor);
|
|
line_to(first_point_in_subpath);
|
|
}
|
|
}
|
|
}
|
|
|
|
ByteString Path::to_byte_string() const
|
|
{
|
|
// Dumps this path as an SVG compatible string.
|
|
StringBuilder builder;
|
|
if (is_empty() || m_commands.first() != PathSegment::MoveTo)
|
|
builder.append("M 0,0"sv);
|
|
for (auto segment : *this) {
|
|
if (!builder.is_empty())
|
|
builder.append(' ');
|
|
switch (segment.command()) {
|
|
case PathSegment::MoveTo:
|
|
builder.append('M');
|
|
break;
|
|
case PathSegment::LineTo:
|
|
builder.append('L');
|
|
break;
|
|
case PathSegment::QuadraticBezierCurveTo:
|
|
builder.append('Q');
|
|
break;
|
|
case PathSegment::CubicBezierCurveTo:
|
|
builder.append('C');
|
|
break;
|
|
case PathSegment::ClosePath:
|
|
builder.append('Z');
|
|
break;
|
|
}
|
|
for (auto point : segment.points())
|
|
builder.appendff(" {},{}", point.x(), point.y());
|
|
}
|
|
return builder.to_byte_string();
|
|
}
|
|
|
|
void Path::segmentize_path()
|
|
{
|
|
Vector<FloatLine> segments;
|
|
FloatBoundingBox bounding_box;
|
|
Vector<size_t> subpath_end_indices;
|
|
|
|
auto add_line = [&](auto const& p0, auto const& p1) {
|
|
segments.append({ p0, p1 });
|
|
bounding_box.add_point(p1);
|
|
};
|
|
|
|
FloatPoint cursor { 0, 0 };
|
|
for (auto segment : *this) {
|
|
switch (segment.command()) {
|
|
case PathSegment::MoveTo:
|
|
bounding_box.add_point(segment.point());
|
|
break;
|
|
case PathSegment::LineTo: {
|
|
add_line(cursor, segment.point());
|
|
break;
|
|
}
|
|
case PathSegment::QuadraticBezierCurveTo: {
|
|
Painter::for_each_line_segment_on_bezier_curve(segment.through(), cursor, segment.point(), [&](FloatPoint p0, FloatPoint p1) {
|
|
add_line(p0, p1);
|
|
});
|
|
break;
|
|
}
|
|
case PathSegment::CubicBezierCurveTo: {
|
|
Painter::for_each_line_segment_on_cubic_bezier_curve(segment.through_0(), segment.through_1(), cursor, segment.point(), [&](FloatPoint p0, FloatPoint p1) {
|
|
add_line(p0, p1);
|
|
});
|
|
break;
|
|
}
|
|
case PathSegment::ClosePath: {
|
|
subpath_end_indices.append(segments.size() - 1);
|
|
break;
|
|
}
|
|
}
|
|
if (segment.command() != PathSegment::ClosePath)
|
|
cursor = segment.point();
|
|
}
|
|
|
|
m_split_lines = SplitLines { move(segments), bounding_box, move(subpath_end_indices) };
|
|
}
|
|
|
|
Path Path::copy_transformed(Gfx::AffineTransform const& transform) const
|
|
{
|
|
Path result;
|
|
result.m_commands = m_commands;
|
|
result.m_points.ensure_capacity(m_points.size());
|
|
for (auto point : m_points)
|
|
result.m_points.unchecked_append(transform.map(point));
|
|
return result;
|
|
}
|
|
|
|
void Path::transform(AffineTransform const& transform)
|
|
{
|
|
for (auto& point : m_points)
|
|
point = transform.map(point);
|
|
}
|
|
|
|
void Path::append_path(Path const& path, AppendRelativeToLastPoint relative_to_last_point)
|
|
{
|
|
auto previous_last_point = last_point();
|
|
auto new_points_start = m_points.size();
|
|
m_commands.extend(path.m_commands);
|
|
m_points.extend(path.m_points);
|
|
if (relative_to_last_point == AppendRelativeToLastPoint::Yes) {
|
|
for (size_t i = new_points_start; i < m_points.size(); i++)
|
|
m_points[i] += previous_last_point;
|
|
}
|
|
invalidate_split_lines();
|
|
}
|
|
|
|
template<typename T>
|
|
struct RoundTrip {
|
|
RoundTrip(ReadonlySpan<T> span)
|
|
: m_span(span)
|
|
{
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
return m_span.size() * 2 - 1;
|
|
}
|
|
|
|
T const& operator[](size_t index) const
|
|
{
|
|
// Follow the path:
|
|
if (index < m_span.size())
|
|
return m_span[index];
|
|
// Then in reverse:
|
|
if (index < size())
|
|
return m_span[size() - index - 1];
|
|
// Then wrap around again:
|
|
return m_span[index - size() + 1];
|
|
}
|
|
|
|
private:
|
|
ReadonlySpan<T> m_span;
|
|
};
|
|
|
|
static Vector<FloatPoint, 128> make_pen(float thickness)
|
|
{
|
|
constexpr auto flatness = 0.15f;
|
|
auto pen_vertex_count = 4;
|
|
if (thickness > flatness) {
|
|
pen_vertex_count = max(
|
|
static_cast<int>(ceilf(AK::Pi<float>
|
|
/ acosf(1 - (2 * flatness) / thickness))),
|
|
pen_vertex_count);
|
|
}
|
|
|
|
if (pen_vertex_count % 2 == 1)
|
|
pen_vertex_count += 1;
|
|
|
|
Vector<FloatPoint, 128> pen_vertices;
|
|
pen_vertices.ensure_capacity(pen_vertex_count);
|
|
|
|
// Generate vertices for the pen (going counterclockwise). The pen does not necessarily need
|
|
// to be a circle (or an approximation of one), but other shapes are untested.
|
|
float theta = 0;
|
|
float theta_delta = (AK::Pi<float> * 2) / pen_vertex_count;
|
|
for (int i = 0; i < pen_vertex_count; i++) {
|
|
float sin_theta;
|
|
float cos_theta;
|
|
AK::sincos(theta, sin_theta, cos_theta);
|
|
pen_vertices.unchecked_append({ cos_theta * thickness / 2, sin_theta * thickness / 2 });
|
|
theta -= theta_delta;
|
|
}
|
|
|
|
return pen_vertices;
|
|
}
|
|
|
|
static void apply_dash_pattern(Vector<Vector<FloatPoint>>& segments, Vector<bool>& segment_is_closed, Vector<float> dash_pattern, float dash_offset)
|
|
{
|
|
VERIFY(!dash_pattern.is_empty());
|
|
|
|
// Has to be ensured by callers. (They all double the list, but <canvas> needs to do that in a way that
|
|
// is visible to JS accessors, so don't do it here.)
|
|
VERIFY(dash_pattern.size() % 2 == 0);
|
|
|
|
// This implementation is vaguely based on the <canvas> spec. One difference is that the <canvas> spec
|
|
// modifies the path in place, while this implementation returns a new path. The spec is written in terms
|
|
// of [start, end] intervals that are removed from the input path, while we have to instead add the
|
|
// complement of those intervals to the output path. This is done by keeping track of the previous `end`
|
|
// value and then filling in the gap between that and the current `start` value on every interval, and
|
|
// at the end of each subpath.
|
|
|
|
Vector<Vector<FloatPoint>> new_segments;
|
|
|
|
// https://html.spec.whatwg.org/multipage/canvas.html#line-styles:dash-list-5
|
|
// 7. Let `pattern width` be the concatenation of all the entries of style's dash list, in coordinate space units.
|
|
// (NOTE: The spec means sum, not concatenation.)
|
|
float pattern_width = 0;
|
|
for (auto& entry : dash_pattern) {
|
|
VERIFY(entry >= 0);
|
|
pattern_width += entry;
|
|
}
|
|
|
|
// 8. For each subpath `subpath` in `path`, run the following substeps. These substeps mutate the subpaths in `path` in vivo.
|
|
for (auto const& [subpath_index, subpath] : enumerate(segments)) {
|
|
float end, last_end = 0;
|
|
|
|
// 1. Let `subpath width` be the length of all the lines of `subpath`, in coordinate space units.
|
|
float subpath_width = 0;
|
|
for (size_t i = 0; i < subpath.size() - 1; i++)
|
|
subpath_width += subpath[i].distance_from(subpath[i + 1]);
|
|
|
|
// 2. Let `offset` be the value of style's lineDashOffset, in coordinate space units.
|
|
float offset = dash_offset;
|
|
|
|
// 3. While `offset` is greater than `pattern width`, decrement it by pattern width.
|
|
// While `offset` is less than zero, increment it by `pattern width`.
|
|
// FIXME: Rewrite this using fmodf() in the future, once this has good test coverage.
|
|
while (offset > pattern_width)
|
|
offset -= pattern_width;
|
|
while (offset < 0)
|
|
offset += pattern_width;
|
|
|
|
// 4. Define `L` to be a linear coordinate line defined along all lines in subpath, such that the start of the first line
|
|
// in the subpath is defined as coordinate 0, and the end of the last line in the subpath is defined as coordinate `subpath width`.
|
|
float L = 0;
|
|
size_t current_vertex_index = 0;
|
|
|
|
auto next_L = [&]() -> float {
|
|
return L + subpath[current_vertex_index].distance_from(subpath[current_vertex_index + 1]);
|
|
};
|
|
|
|
auto append_distinct = [](Vector<FloatPoint>& path, FloatPoint p) {
|
|
if (path.is_empty() || path.last() != p)
|
|
path.append(p);
|
|
};
|
|
|
|
auto skip_until = [&](float target_L) {
|
|
while (next_L() < target_L) {
|
|
L = next_L();
|
|
current_vertex_index++;
|
|
}
|
|
};
|
|
|
|
auto append_until = [&](Vector<FloatPoint>& new_subpath, float target_L) {
|
|
while (next_L() < target_L) {
|
|
L = next_L();
|
|
current_vertex_index++;
|
|
append_distinct(new_subpath, subpath[current_vertex_index]);
|
|
}
|
|
};
|
|
|
|
auto append_lerp = [&](Vector<FloatPoint>& new_subpath, float target_L) {
|
|
VERIFY(target_L >= L);
|
|
VERIFY(target_L <= next_L());
|
|
append_distinct(new_subpath, mix(subpath[current_vertex_index], subpath[current_vertex_index + 1], (target_L - L) / (next_L() - L)));
|
|
};
|
|
|
|
// 5. Let `position` be zero minus offset.
|
|
float position = -offset;
|
|
|
|
// 6. Let `index` be 0.
|
|
size_t index = 0;
|
|
|
|
// 7. Let `current state` be off (the other states being on and zero-on).
|
|
// (NOTE: The mentioned "zero-on" state in the spec appears unused.)
|
|
enum class State {
|
|
Off,
|
|
On,
|
|
};
|
|
State current_state = State::Off;
|
|
|
|
dash_on:
|
|
// 8. Dash on: Let `segment length` be the value of style's dash list's `index`th entry.
|
|
float segment_length = dash_pattern[index];
|
|
|
|
// 9. Increment `position` by `segment length`.
|
|
position += segment_length;
|
|
|
|
// 10. If `position` is greater than `subpath width`, then end these substeps for this subpath and start them again for the next subpath;
|
|
// if there are no more subpaths, then jump to the step labeled `convert` instead.
|
|
if (position > subpath_width) {
|
|
if (last_end < subpath_width) {
|
|
// Fill from last_end to subpath_width.
|
|
Vector<FloatPoint> new_subpath;
|
|
|
|
skip_until(last_end);
|
|
append_lerp(new_subpath, last_end);
|
|
for (++current_vertex_index; current_vertex_index < subpath.size(); ++current_vertex_index)
|
|
append_distinct(new_subpath, subpath[current_vertex_index]);
|
|
|
|
new_segments.append(move(new_subpath));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// 11. If `segment length` is nonzero, then let current state be on.
|
|
if (segment_length != 0)
|
|
current_state = State::On;
|
|
|
|
// 12. Increment `index` by one.
|
|
index++;
|
|
|
|
// 13. Dash off: Let segment length be the value of style's dash list's `index`th entry.
|
|
// (NOTE: The label "Dash off:" in the spec appears unused.)
|
|
segment_length = dash_pattern[index];
|
|
|
|
// 14. Let `start` be the offset `position` on L.
|
|
float start = position;
|
|
|
|
// 15. Increment `position` by `segment length`.
|
|
position += segment_length;
|
|
|
|
// 16. If `position` is less than zero, then jump to the step labeled `post-cut`.
|
|
if (position < 0)
|
|
goto post_cut;
|
|
|
|
// 17. If `start` is less than zero, then let `start` be zero.
|
|
if (start < 0)
|
|
start = 0;
|
|
|
|
// 18. If `position` is greater than `subpath width`, then let `end` be the offset `subpath width` on `L`. Otherwise, let `end` be the offset `position` on `L`.
|
|
end = position > subpath_width ? subpath_width : position;
|
|
|
|
// 19. Jump to the first appropriate step:
|
|
// If segment length is zero and current state is off
|
|
// Do nothing, just continue to the next step.
|
|
// If current state is off
|
|
// Cut the line on which `end` finds itself short at `end` and place a point there, cutting in two the subpath that it was in;
|
|
// remove all line segments, joins, points, and subpaths that are between `start` and `end`; and finally place a single point at
|
|
// `start` with no lines connecting to it.
|
|
// The point has a directionality for the purposes of drawing line caps (see below). The directionality is the direction that
|
|
// the original line had at that point (i.e. when `L` was defined above).
|
|
// Otherwise
|
|
// Cut the line on which `start` finds itself into two at `start` and place a point there, cutting in two the subpath that it was in,
|
|
// and similarly cut the line on which `end` finds itself short at end and place a point there, cutting in two the subpath that it was in,
|
|
// and then remove all line segments, joins, points, and subpaths that are between `start` and `end`.
|
|
if (segment_length == 0 && current_state == State::Off) {
|
|
// Do nothing.
|
|
} else if (current_state == State::Off) {
|
|
Vector<FloatPoint> new_subpath;
|
|
|
|
skip_until(start);
|
|
append_lerp(new_subpath, start);
|
|
|
|
// FIXME: Store directionality.
|
|
new_segments.append(move(new_subpath));
|
|
} else {
|
|
Vector<FloatPoint> new_subpath;
|
|
|
|
skip_until(last_end);
|
|
append_lerp(new_subpath, last_end);
|
|
append_until(new_subpath, start);
|
|
append_lerp(new_subpath, start);
|
|
|
|
new_segments.append(move(new_subpath));
|
|
last_end = end;
|
|
}
|
|
|
|
// 20. If start and end are the same point, then this results in just the line being cut in two and two points being inserted there,
|
|
// with nothing being removed, unless a join also happens to be at that point, in which case the join must be removed.
|
|
// FIXME: Not clear if we have to do anything here, given our inverted interval implementation.
|
|
|
|
post_cut:
|
|
// 21. Post-cut: If position is greater than subpath width, then jump to the step labeled convert.
|
|
if (position > subpath_width)
|
|
break;
|
|
|
|
// 22. If segment length is greater than zero, then let positioned-at-on-dash be false.
|
|
// (NOTE: The spec doesn't mention positioned-at-on-dash anywhere else.)
|
|
|
|
// 23. Increment index by one. If it is equal to the number of entries in style's dash list, then let index be 0.
|
|
index++;
|
|
if (index == dash_pattern.size())
|
|
index = 0;
|
|
|
|
// 24. Return to the step labeled `dash on`.
|
|
goto dash_on;
|
|
}
|
|
|
|
segments = move(new_segments);
|
|
|
|
// This function is only called if there are dashes, and dashes are never closed.
|
|
segment_is_closed.resize(segments.size());
|
|
for (auto& is_closed : segment_is_closed)
|
|
is_closed = false;
|
|
}
|
|
|
|
Path Path::stroke_to_fill(StrokeStyle const& style) const
|
|
{
|
|
// Note: This convolves a polygon with the path using the algorithm described
|
|
// in https://keithp.com/~keithp/talks/cairo2003.pdf (3.1 Stroking Splines via Convolution)
|
|
// Cap style handling is done by replacing the convolution with an explicit shape
|
|
// at the path's ends, but we still maintain a position on the pen and pretend we're convolving.
|
|
|
|
auto thickness = style.thickness;
|
|
auto cap_style = style.cap_style;
|
|
auto join_style = style.join_style;
|
|
|
|
VERIFY(thickness > 0);
|
|
|
|
auto lines = split_lines();
|
|
if (lines.is_empty())
|
|
return Path {};
|
|
|
|
auto subpath_end_indices = split_lines_subbpath_end_indices();
|
|
|
|
// Paths can be disconnected, which a pain to deal with, so split it up.
|
|
// Also filter out duplicate points here (but keep one-point paths around
|
|
// since we draw round and square caps for them).
|
|
Vector<Vector<FloatPoint>> segments;
|
|
Vector<bool> segment_is_closed;
|
|
segments.append({ lines.first().a() });
|
|
for (auto const& [line_index, line] : enumerate(lines)) {
|
|
if (line.a() == segments.last().last()) {
|
|
if (line.a() != line.b())
|
|
segments.last().append(line.b());
|
|
} else {
|
|
if (subpath_end_indices.size() >= segments.size())
|
|
segment_is_closed.append(subpath_end_indices[segments.size() - 1] == line_index);
|
|
else
|
|
segment_is_closed.append(false);
|
|
segments.append({ line.a() });
|
|
if (line.a() != line.b())
|
|
segments.last().append(line.b());
|
|
}
|
|
}
|
|
if (segment_is_closed.size() < segments.size()) {
|
|
if (subpath_end_indices.size() >= segments.size())
|
|
segment_is_closed.append(subpath_end_indices[segments.size() - 1] == lines.size() - 1);
|
|
else
|
|
segment_is_closed.append(false);
|
|
VERIFY(segment_is_closed.size() == segments.size());
|
|
}
|
|
|
|
if (!style.dash_pattern.is_empty())
|
|
apply_dash_pattern(segments, segment_is_closed, style.dash_pattern, style.dash_offset);
|
|
|
|
Vector<FloatPoint, 128> pen_vertices = make_pen(thickness);
|
|
|
|
static constexpr auto mod = [](int a, int b) {
|
|
VERIFY(b > 0);
|
|
VERIFY(a + b >= 0);
|
|
return (a + b) % b;
|
|
};
|
|
auto wrapping_index = [](auto& vertices, auto index) {
|
|
return vertices[mod(index, vertices.size())];
|
|
};
|
|
|
|
auto angle_between = [](auto p1, auto p2) {
|
|
auto delta = p2 - p1;
|
|
return atan2f(delta.y(), delta.x());
|
|
};
|
|
|
|
struct ActiveRange {
|
|
float start;
|
|
float end;
|
|
|
|
bool in_range(float angle) const
|
|
{
|
|
// Note: Since active ranges go counterclockwise start > end unless we wrap around at 180 degrees
|
|
return ((angle <= start && angle >= end)
|
|
|| (start < end && angle <= start)
|
|
|| (start < end && angle >= end));
|
|
}
|
|
};
|
|
|
|
Vector<ActiveRange, 128> active_ranges;
|
|
active_ranges.ensure_capacity(pen_vertices.size());
|
|
for (int i = 0; i < (int)pen_vertices.size(); i++) {
|
|
active_ranges.unchecked_append({ angle_between(wrapping_index(pen_vertices, i - 1), pen_vertices[i]),
|
|
angle_between(pen_vertices[i], wrapping_index(pen_vertices, i + 1)) });
|
|
}
|
|
|
|
auto clockwise = [](float current_angle, float target_angle) {
|
|
if (target_angle < 0)
|
|
target_angle += AK::Pi<float> * 2;
|
|
if (current_angle < 0)
|
|
current_angle += AK::Pi<float> * 2;
|
|
if (target_angle < current_angle)
|
|
target_angle += AK::Pi<float> * 2;
|
|
|
|
auto angle = target_angle - current_angle;
|
|
|
|
// If the end of the range is antiparallel to where we want to go,
|
|
// we have to keep moving clockwise: In that case, the _next_ range
|
|
// is what we want.
|
|
if (fabs(angle - AK::Pi<float>) < 0.0001f)
|
|
return true;
|
|
|
|
return angle <= AK::Pi<float>;
|
|
};
|
|
|
|
Path convolution;
|
|
for (auto const& [segment_index, segment] : enumerate(segments)) {
|
|
if (segment.size() < 2) {
|
|
// Draw round and square caps for single-point segments.
|
|
// FIXME: THis is is a bit ad-hoc. It matches what most PDF engines do,
|
|
// and matches what Chrome and Firefox (but not WebKit) do for canvas paths.
|
|
if (cap_style == CapStyle::Round) {
|
|
convolution.move_to(segment[0] + pen_vertices[0]);
|
|
for (int i = 1; i < (int)pen_vertices.size(); i++)
|
|
convolution.line_to(segment[0] + pen_vertices[i]);
|
|
convolution.close();
|
|
} else if (cap_style == CapStyle::Square) {
|
|
convolution.rect({ segment[0].translated(-thickness / 2, -thickness / 2), { thickness, thickness } });
|
|
}
|
|
continue;
|
|
}
|
|
|
|
RoundTrip<FloatPoint> shape { segment };
|
|
|
|
bool first = true;
|
|
auto add_vertex = [&](auto v) {
|
|
if (first) {
|
|
convolution.move_to(v);
|
|
first = false;
|
|
} else {
|
|
convolution.line_to(v);
|
|
}
|
|
};
|
|
|
|
auto shape_idx = 0u;
|
|
|
|
auto slope = [&] {
|
|
return angle_between(shape[shape_idx], shape[shape_idx + 1]);
|
|
};
|
|
|
|
auto start_slope = slope();
|
|
// Note: At least one range must be active.
|
|
int active = *active_ranges.find_first_index_if([&](auto& range) {
|
|
return range.in_range(start_slope);
|
|
});
|
|
|
|
shape_idx = 1;
|
|
|
|
auto add_round_join = [&](unsigned next_index) {
|
|
add_vertex(shape[shape_idx] + pen_vertices[active]);
|
|
auto slope_now = angle_between(shape[shape_idx], shape[next_index]);
|
|
auto range = active_ranges[active];
|
|
while (!range.in_range(slope_now)) {
|
|
active = mod(active + (clockwise(slope_now, range.end) ? 1 : -1), pen_vertices.size());
|
|
add_vertex(shape[shape_idx] + pen_vertices[active]);
|
|
range = active_ranges[active];
|
|
}
|
|
};
|
|
|
|
auto add_bevel_join = [&](unsigned next_index) {
|
|
add_vertex(shape[shape_idx] + pen_vertices[active]);
|
|
auto slope_now = angle_between(shape[shape_idx], shape[next_index]);
|
|
auto range = active_ranges[active];
|
|
auto last_active = active;
|
|
while (!range.in_range(slope_now)) {
|
|
last_active = active;
|
|
active = mod(active + (clockwise(slope_now, range.end) ? 1 : -1), pen_vertices.size());
|
|
range = active_ranges[active];
|
|
}
|
|
if (last_active != active)
|
|
add_vertex(shape[shape_idx] + pen_vertices[active]);
|
|
};
|
|
|
|
auto add_miter_join = [&](unsigned next_index) {
|
|
auto cross_product = [](FloatPoint const& p1, FloatPoint const& p2) {
|
|
return p1.x() * p2.y() - p1.y() * p2.x();
|
|
};
|
|
|
|
auto segment1 = shape[shape_idx] - shape[shape_idx - 1];
|
|
auto normal1 = FloatVector2(-segment1.y(), segment1.x()).normalized();
|
|
auto offset1 = FloatPoint(normal1.x(), normal1.y()) * (thickness / 2);
|
|
auto p1 = shape[shape_idx - 1] + offset1;
|
|
|
|
auto segment2 = shape[next_index] - shape[shape_idx];
|
|
auto normal2 = FloatVector2(-segment2.y(), segment2.x()).normalized();
|
|
auto offset2 = FloatPoint(normal2.x(), normal2.y()) * (thickness / 2);
|
|
auto p2 = shape[shape_idx] + offset2;
|
|
|
|
auto denominator = cross_product(segment1, segment2);
|
|
if (denominator == 0)
|
|
return add_bevel_join(next_index);
|
|
|
|
auto intersection = p1 + segment1 * cross_product(p2 - p1, segment2) / denominator;
|
|
if (intersection.distance_from(shape[shape_idx]) / (thickness / 2) > style.miter_limit)
|
|
return add_bevel_join(next_index);
|
|
|
|
add_vertex(intersection);
|
|
auto slope_now = angle_between(shape[shape_idx], shape[next_index]);
|
|
auto range = active_ranges[active];
|
|
while (!range.in_range(slope_now)) {
|
|
active = mod(active + (clockwise(slope_now, range.end) ? 1 : -1), pen_vertices.size());
|
|
range = active_ranges[active];
|
|
}
|
|
};
|
|
|
|
auto add_linejoin = [&](unsigned next_index) {
|
|
switch (join_style) {
|
|
case JoinStyle::Miter:
|
|
add_miter_join(next_index);
|
|
break;
|
|
case JoinStyle::Round:
|
|
add_round_join(next_index);
|
|
break;
|
|
case JoinStyle::Bevel:
|
|
add_bevel_join(next_index);
|
|
break;
|
|
}
|
|
};
|
|
|
|
auto trace_path_until_index = [&](size_t index) {
|
|
while (shape_idx < index) {
|
|
add_linejoin(shape_idx + 1);
|
|
shape_idx++;
|
|
}
|
|
};
|
|
|
|
auto add_linecap = [&]() {
|
|
if (cap_style == CapStyle::Butt || cap_style == CapStyle::Square) {
|
|
auto segment = shape[shape_idx] - shape[shape_idx - 1];
|
|
auto segment_vector = FloatVector2(segment.x(), segment.y()).normalized();
|
|
auto normal = FloatVector2(-segment_vector.y(), segment_vector.x());
|
|
auto offset = FloatPoint(normal.x() * (thickness / 2), normal.y() * (thickness / 2));
|
|
auto p1 = shape[shape_idx] + offset;
|
|
auto p2 = shape[shape_idx] - offset;
|
|
if (cap_style == CapStyle::Square) {
|
|
auto square_cap_offset = segment_vector * (thickness / 2);
|
|
p1.translate_by(square_cap_offset.x(), square_cap_offset.y());
|
|
p2.translate_by(square_cap_offset.x(), square_cap_offset.y());
|
|
}
|
|
|
|
add_vertex(p1);
|
|
auto slope_now = slope();
|
|
active = mod(active + pen_vertices.size() / 2, pen_vertices.size());
|
|
if (!active_ranges[active].in_range(slope_now)) {
|
|
if (wrapping_index(active_ranges, active + 1).in_range(slope_now))
|
|
active = mod(active + 1, pen_vertices.size());
|
|
else if (wrapping_index(active_ranges, active - 1).in_range(slope_now))
|
|
active = mod(active - 1, pen_vertices.size());
|
|
else
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
add_vertex(p2);
|
|
shape_idx++;
|
|
} else {
|
|
VERIFY(cap_style == CapStyle::Round);
|
|
add_round_join(shape_idx + 1);
|
|
}
|
|
};
|
|
|
|
bool current_segment_is_closed = segment_is_closed[segment_index];
|
|
|
|
// Outer stroke.
|
|
trace_path_until_index(segment.size() - 1);
|
|
VERIFY(shape_idx == segment.size() - 1);
|
|
|
|
// Close outer stroke for closed paths, or draw cap 1 for open paths.
|
|
if (current_segment_is_closed) {
|
|
add_linejoin(1);
|
|
|
|
// Start an independent path for the inner stroke.
|
|
convolution.close();
|
|
first = true;
|
|
|
|
auto start_slope = slope();
|
|
active = *active_ranges.find_first_index_if([&](auto& range) {
|
|
return range.in_range(start_slope);
|
|
});
|
|
|
|
++shape_idx;
|
|
VERIFY(shape_idx == segment.size());
|
|
} else {
|
|
add_linecap();
|
|
}
|
|
|
|
// Inner stroke.
|
|
trace_path_until_index(2 * (segment.size() - 1));
|
|
VERIFY(shape_idx == 2 * (segment.size() - 1));
|
|
|
|
// Close inner stroke for closed paths, or draw cap 2 for open paths.
|
|
if (current_segment_is_closed) {
|
|
add_linejoin(segment.size());
|
|
} else {
|
|
add_linecap();
|
|
}
|
|
|
|
convolution.close();
|
|
}
|
|
|
|
return convolution;
|
|
}
|
|
|
|
}
|