The Tor Browser: comparison gfx/2d/PathHelpers.cpp

--1:000000000000
+:9e32b0e971a3
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "PathHelpers.h"
+namespace mozilla {
+namespace gfx {
+void
+AppendRoundedRectToPath(PathBuilder* aPathBuilder,
+const Rect& aRect,
+// paren's needed due to operator precedence:
+const Size(& aCornerRadii)[4],
+bool aDrawClockwise)
+{
+// For CW drawing, this looks like:
+//
+//  ...******0**      1    C
+//              ****
+//                  ***    2
+//                     **
+//                       *
+//                        *
+//                         3
+//                         *
+//                         *
+//
+// Where 0, 1, 2, 3 are the control points of the Bezier curve for
+// the corner, and C is the actual corner point.
+//
+// At the start of the loop, the current point is assumed to be
+// the point adjacent to the top left corner on the top
+// horizontal.  Note that corner indices start at the top left and
+// continue clockwise, whereas in our loop i = 0 refers to the top
+// right corner.
+//
+// When going CCW, the control points are swapped, and the first
+// corner that's drawn is the top left (along with the top segment).
+//
+// There is considerable latitude in how one chooses the four
+// control points for a Bezier curve approximation to an ellipse.
+// For the overall path to be continuous and show no corner at the
+// endpoints of the arc, points 0 and 3 must be at the ends of the
+// straight segments of the rectangle; points 0, 1, and C must be
+// collinear; and points 3, 2, and C must also be collinear.  This
+// leaves only two free parameters: the ratio of the line segments
+// 01 and 0C, and the ratio of the line segments 32 and 3C.  See
+// the following papers for extensive discussion of how to choose
+// these ratios:
+//
+//   Dokken, Tor, et al. "Good approximation of circles by
+//      curvature-continuous Bezier curves."  Computer-Aided
+//      Geometric Design 7(1990) 33--41.
+//   Goldapp, Michael. "Approximation of circular arcs by cubic
+//      polynomials." Computer-Aided Geometric Design 8(1991) 227--238.
+//   Maisonobe, Luc. "Drawing an elliptical arc using polylines,
+//      quadratic, or cubic Bezier curves."
+//      http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
+//
+// We follow the approach in section 2 of Goldapp (least-error,
+// Hermite-type approximation) and make both ratios equal to
+//
+//          2   2 + n - sqrt(2n + 28)
+//  alpha = - * ---------------------
+//          3           n - 4
+//
+// where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ).
+//
+// This is the result of Goldapp's equation (10b) when the angle
+// swept out by the arc is pi/2, and the parameter "a-bar" is the
+// expression given immediately below equation (21).
+//
+// Using this value, the maximum radial error for a circle, as a
+// fraction of the radius, is on the order of 0.2 x 10^-3.
+// Neither Dokken nor Goldapp discusses error for a general
+// ellipse; Maisonobe does, but his choice of control points
+// follows different constraints, and Goldapp's expression for
+// 'alpha' gives much smaller radial error, even for very flat
+// ellipses, than Maisonobe's equivalent.
+//
+// For the various corners and for each axis, the sign of this
+// constant changes, or it might be 0 -- it's multiplied by the
+// appropriate multiplier from the list before using.
+const Float alpha = Float(0.55191497064665766025);
+typedef struct { Float a, b; } twoFloats;
+twoFloats cwCornerMults[4] = { { -1,  0 },    // cc == clockwise
+{  0, -1 },
+{ +1,  0 },
+{  0, +1 } };
+twoFloats ccwCornerMults[4] = { { +1,  0 },   // ccw == counter-clockwise
+{  0, -1 },
+{ -1,  0 },
+{  0, +1 } };
+twoFloats *cornerMults = aDrawClockwise ? cwCornerMults : ccwCornerMults;
+Point cornerCoords[] = { aRect.TopLeft(), aRect.TopRight(),
+aRect.BottomRight(), aRect.BottomLeft() };
+Point pc, p0, p1, p2, p3;
+// The indexes of the corners:
+const int kTopLeft = 0, kTopRight = 1;
+if (aDrawClockwise) {
+aPathBuilder->MoveTo(Point(aRect.X() + aCornerRadii[kTopLeft].width,
+aRect.Y()));
+} else {
+aPathBuilder->MoveTo(Point(aRect.X() + aRect.Width() - aCornerRadii[kTopRight].width,
+aRect.Y()));
+}
+for (int i = 0; i < 4; ++i) {
+// the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
+int c = aDrawClockwise ? ((i+1) % 4) : ((4-i) % 4);
+// i+2 and i+3 respectively.  These are used to index into the corner
+// multiplier table, and were deduced by calculating out the long form
+// of each corner and finding a pattern in the signs and values.
+int i2 = (i+2) % 4;
+int i3 = (i+3) % 4;
+pc = cornerCoords[c];
+if (aCornerRadii[c].width > 0.0 && aCornerRadii[c].height > 0.0) {
+p0.x = pc.x + cornerMults[i].a * aCornerRadii[c].width;
+p0.y = pc.y + cornerMults[i].b * aCornerRadii[c].height;
+p3.x = pc.x + cornerMults[i3].a * aCornerRadii[c].width;
+p3.y = pc.y + cornerMults[i3].b * aCornerRadii[c].height;
+p1.x = p0.x + alpha * cornerMults[i2].a * aCornerRadii[c].width;
+p1.y = p0.y + alpha * cornerMults[i2].b * aCornerRadii[c].height;
+p2.x = p3.x - alpha * cornerMults[i3].a * aCornerRadii[c].width;
+p2.y = p3.y - alpha * cornerMults[i3].b * aCornerRadii[c].height;
+aPathBuilder->LineTo(p0);
+aPathBuilder->BezierTo(p1, p2, p3);
+} else {
+aPathBuilder->LineTo(pc);
+}
+}
+aPathBuilder->Close();
+}
+void
+AppendEllipseToPath(PathBuilder* aPathBuilder,
+const Point& aCenter,
+const Size& aDimensions)
+{
+Size halfDim = aDimensions / 2.0;
+Rect rect(aCenter - Point(halfDim.width, halfDim.height), aDimensions);
+Size radii[] = { halfDim, halfDim, halfDim, halfDim };
+AppendRoundedRectToPath(aPathBuilder, rect, radii);
+}
+} // namespace gfx
+} // namespace mozilla

The Tor Browser / file comparison

comparison: gfx/2d/PathHelpers.cpp

gfx/2d/PathHelpers.cpp