Pens: automatic processing

[madig]

So, while fiddling with #2202, I found that there's some magic in adapter pens like BasePointToSegmentPen that drops empty contours on endPath, shifts contours so they start on an on-curve and turns single-point contours into open ones. I am not familiar with the complexities of adapters so I'm wondering if these are optimizations or rather intrinsically needed? Should point pens be expected to do any of these optimizations, too?

Side question: why does ReverseContourPointPen require that a component is only added while a contour drawing is not in progress?

[justvanrossum]

drops empty contours on endPath

Empty contours can't be represented with segment pens

shifts contours so they start on an on-curve

Segment pens can't start a path on an offcurve (except for the on-curve-less quad blob)

turns single-point contours into open ones

Not sure, but a closed single-point path doesn't make much sense, either

why does ReverseContourPointPen require that a component is only added while a contour drawing is not in progress

Because it doesn't make sense to add a component in between a beginPath and an endPath call. Perhaps that's an aspect of the protocol that should be formally described. There's no real technical reason to disallow it, it just doesn't make sense: why would one want to do that?

[madig]

There is no problem, I just wanted to better understand why the starting point is moved to the end.

[madig]

More questions!

In [5]: p = _TestPen()
In [6]: p.qCurveTo((100,100))
100 100 lineto

In [9]: r2 = RecordingPen()
In [10]: p2 = PointToSegmentPen(r2)
In [12]: p2.beginPath()
In [13]: p2.addPoint((100,100), segmentType="qcurve")
In [14]: p2.endPath()
In [15]: r2.value
Out[15]: [('moveTo', ((100, 100),)), ('endPath', ())]

BasePen turns single points into lines, PointToSegmentPen into moves?

[justvanrossum]

You're comparing apples and oranges.

• A segment pen subpath must start with a moveTo, unless you're drawing a quad blob (last qCurve arg is None), so the first example is invalid.

• qCurve takes one or more arguments. The one-argument case is debatable (perhaps it shouldn't have been allowed), but a single on-curve point does not make a curve. BasePen can't call _qCurveOne, so it falls back to a line. (It's based on TT curves: two consecutive on-curve points form a line.)

• You're converting a point pen sequence to segments. You're adding a single on-curve point, but nothing else. This is the same as adding a single "line" point, and PointToSegmentPen turns a single-point closed contour into a single-point open contour, for whatever reason. But it has to output a moveTo to the receiving segment pen, because that's how segment pens work (see the first bullet).

[madig]

Thanks but 🤯

A segment pen subpath must start with a moveTo, unless you're drawing a quad blob (last qCurve arg is None), so the first example is invalid.

Why is the quad blob exempt?

[justvanrossum]

Because a quad blob has no on-curve points at all. Otherwise it would not be a quad blob. It's a TT-specific thing that fits poorly in the segment pen protocol, but I felt was important enough to create a weird exception for.