I can't say for sure, but just thinking about the editing I'd been doing when I ran into the problem, open paths would be the more likely explanation. Anyway, it's working now—time to move on to new problems.

Okay, now I feel embarrassed: just tried a test, as follows:

canvas = 500

newPage(canvas, canvas)
translate(canvas/2, canvas/2)
path = BezierPath()
path.arc((0, 0), 200, 0, 540, False)
path.lineTo((-100, 0))
path.arc((0, 0), 100, 540, 0, True)
path.closePath()
stroke(0)
fill(None)
path.closePath()

path.removeOverlap()
drawPath(path)

saveImage('~/Desktop/overlap_test.png')

and got this:

Just what I thought should happen! So I tried again with the original code I'm working on—and I swear I put the removeOverlap() call in the same place—and here's the result:

So, great! The function works as I originally thought it should! But, on the other hand, I have no idea why it wouldn't perform when I first tried it.

@gferreira As soon as I get a chance first thing in the AM. By the way and in case it matters (though I don't see why it should), the curves are drawn with arcTo().

By the way, here's the context. The appearance of the black-filled outline is correct, but I want to lose the overlap to allow me to layer and selectively remove copies of the outlines to create Schrofer's various stroke effects.

Gustavo, thanks. Here's the path.points from the outline above. Sorry I haven't had a chance yet to get round() inserted into all the calculations where it needs to be, yet.

[(-125.0, 275.0),
(-125.0, -100.0),
(-125.0, -99.99999999999999),
(-125.0, -113.80711874576983),
(-113.80711874576983, -124.99999999999999),
(-100.0, -124.99999999999999),
(125.0, -125.0),
(125.0, 100.0),
(125.0, 100.0),
(125.0, 113.80711874576983),
(113.80711874576983, 125.0),
(100.0, 125.0),
(-275.0, 125.0),
(-275.0, 275.0),
(100.0, 275.0),
(99.99999999999999, 275.0),
(196.64983122038882, 275.0),
(275.0, 196.64983122038882),
(275.0, 100.0),
(275.0, -275.0),
(-100.0, -275.0),
(-100.00000000000003, -275.0),
(-196.64983122038888, -275.0),
(-275.0, -196.64983122038882),
(-275.0, -99.99999999999997),
(-275.0, 275.0),
(-125.0, 275.0)]

A quick and hopefully not-too-dumb question about BezierPath() overlaps: what's the Boolean operation would allow me to get rid of an overlap like the one in the upper-left-hand corner of this path? removeOverlap() erases the whole path …

(Gustavo, if you're reading this, I stole the diagram scheme and colors from you.)

@michelangelo Not too late! I can help with stuff like LeWitt and Schrofer, and Crouwel and Albers, etc. anytime.

I've marked the points in the curve to try to make sense of its behavior: green for the starting point, red for the others.

canvas = 300
start = (100, 100)
pt1 = (200, 100)
pt2 = (200, 200)
radius = 100

newPage(canvas, canvas)
fill(1)
rect(0, 0, canvas, canvas)

path = BezierPath()

path.moveTo(start)
path.arcTo(pt1, pt2, radius)
fill(None)
stroke(0)
drawPath(path)

stroke(None)
start = list(start)
pt1 = list(pt1)
pt2 = list(pt2)
fill(0, 1, 0)
oval(start[0] - 1, start[1] - 1, 2, 2)
fill(1, 0, 0)
oval(pt1[0] - 1, pt1[1] - 1, 2, 2)
oval(pt2[0] - 1, pt2[1] - 1, 2, 2)

print(path.points)

So that first defined point in arcTo() feels like an off-curve or control point, right? But then pt2 must be more than just the point to which the arc curves, because if I change radius to 400 I get this:

and if I change pt1 to (400, 300) I get this:

I'm just having a hard time telling a story about what these points are doing that makes sense to me …

And since I'm asking: Looking at these lists of points, how do I know which ones are what in an application like Illustrator we'd call the 'corner points', where the 'handles' = off-curve points are not collinear with the 'anchors = on-curve points between them? Again, sorry in advance if these are really elementary questions …

So, there have been two things that have bugged me since I started working with DrawBot a couple years ago. One is very simple and has to do with the documentation for arcTo().

canvas = 500
size = canvas/2

newPage(canvas, canvas)
fill(1)
rect(0, 0, canvas, canvas)
translate(canvas/2, canvas/2)
stroke(0)

p = BezierPath()
p.moveTo((0, size/2))
p.lineTo((0, 0))
p.lineTo((size/2, 0))

print(p.points)
drawPath(p)

My list of points is:
[(0.0, 125.0), (0.0, 0.0), (125.0, 0.0)]

So let's say I want to close that path to make a quarter-circle. The documentation for arcTo() says:

arcTo(pt1, pt2, radius)
Arc from one point to another point with a given radius.

Well, I know the two points I want to connect: (0, size/2) and (size/2, 0). But what does 'radius' tell me in this context? It's obvious for the arc() method, because there you specify a center point with the radius. If I just enter my points and set radius to size/2:

…
p = BezierPath()
p.moveTo((0, size/2))
p.lineTo((0, 0))
p.lineTo((size/2, 0))
p.arcTo((size/2, 0), (0, size/2), size/2)
…

I get a shape visibly unchanged:

and this list of points:
[(0.0, 125.0), (0.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0), (125.0, 0.0)]

If I use (size/2, size/2) as my first point:

…
p = BezierPath()
p.moveTo((0, size/2))
p.lineTo((0, 0))
p.lineTo((size/2, 0))
p.arcTo((size/2, size/2), (0, size/2), size/2)
…

I get the shape I want:

and this list of points:
[(0.0, 125.0), (0.0, 0.0), (125.0, 0.0), (125.0, -2.0767666935733048e-14), (125.0, 69.03559372884915), (69.03559372884918, 124.99999999999999), (7.654042494670958e-15, 124.99999999999999), (7.654042494670958e-15, 124.99999999999999), (-4.785710873658687e-14, 124.99999999999999), (-4.785710873658687e-14, 124.99999999999999)]

So does this mean I'm not drawing an arc between xy1 and xy2, but instead defining an off-curve point with xy1 and an on-curve point with xy2? If so, what is radius telling me? Because if I change it to (size), here's the shape I get:

and my list of points:
[(0.0, 125.0), (0.0, 0.0), (125.0, 0.0), (125.0, -125.00000000000004), (125.0, 13.071187457698286), (13.071187457698343, 124.99999999999994), (-124.99999999999999, 124.99999999999996), (-124.99999999999999, 124.99999999999996), (-125.0000000000001, 124.99999999999996), (-125.0000000000001, 124.99999999999996)]

I have a feeling that learning the answer to what's going on here will suggest the answer to the other thing that's been bugging me, which is the syntax for defining curves with points—how do I know/specify which ones are the on-curve and off-curve points?

Thanks in advance to anyone who can help. I suspect this is something pretty basic which people who get exposed to DrawBot or RoboFont in a different way than I did understand implicitly, so I apologize if my questions sound elementary.