Is there anything happening in PageBot that would be relevant? I confess to having been too caught up job-hunting and moving/settling to be caught up on where Petr and the other contributors are with the project …

This is probably as much a trigonometry question as a Python/DB question, but here goes:

I'm trying to generalize a method for rounding the corners of outlines I'm drawing around a heartline—I already have a solution for when the radius is 1/2 the outline thickness (or stroke width, if you like). I'm using arcTo() to draw the curve.

In the diagram here, the control point for the arcTo() curve is D, defined by the nodes in the heartline path and the change in angle in that path (and constant for all rounding radii).

Given node A, radius r1, and the negative angle A (in this case –45deg to keep the drawing easy), the target for the arcTo() curve, B1, would be defined (Ax + r1 * cos(angle A + 90), Ay + r1 * sin(angleA + 90)).

So I would call arcTo(D, B1, r1) to get a curve that starts at E1 and ends at B1. So far, so good.

But let's say I want the rounding to have the radius r2. How would I define B2 so that I could call arcTo(D, B2, r2), and the function will give me E2 as a starting point? How I get Ax – length(A → C2), Ay + length(C2 → B2)?

I suspect there's a way to do it by somehow drawing the straight lines in the glyphs as curves and pulling the off-curve points various distances away from being collinear with the on-curve points, in one direction or another, as I change the position of those on-curve points.

But, I still struggle to figure out how to tell which are which, in a list of a curve's points, or to write a set of on-curve and off-curve points to a curve to create a shape on purpose—I know what quadratic and cubic curves are, but the order/syntax of the points in the path escapes me. So it may be a long while before I figure anything out …

Right—except: the distortion/changing curve shown in the video changes the location of the on- and off-curve points in the outlines of the glyphs, but doesn't force path segments that are straight into curves.

I suppose one way to start would be to draw a grid of properly curved paths, systematically and progressively distorted/undistorted, then ID all the points of intersection and the path segments, then put together the glyphs from those paths … but last I checked, intersectPoints() doesn't work on open paths? This also sounds like a very long workaround I'm suggesting.

Are there any functions in DrawBot for systematically distorting vectors/BezierPaths? (I know there are plenty for raster images.)

I was hoping to recreate a variation method that Jurriaan Schrofer used especially with his 'q' alphabet, pictured here:

I know I could generate a field, rasterize it, then distort it. Or, I could draw the characters on a grid of systematically variable nodes. But the first methods feels like cheating—I wouldn't be learning much about how Schrofer actually drew the glyphs—and the second would leave me with straight path segments, not curves.

I'm going to spend some quality time with Schrofer's notebooks and also with some books on Escher's process and mathematical methods, to see if I get any hints that way. But if anyone has any ideas I'd be happy to hear them.

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