The finished product, a tribute to Bridget Riley's Rustle 6 (2015).

import math

canvasX = 600
canvasY = 600
nFrames = 120
side = canvasX/14
height = (side * sqrt(3))/2
center = (side/sqrt(3))/2
nX = 14
nY = 15
offsetX = side
offsetY = height

from datetime import *
time = datetime.now()

def interpolate(pt1, pt2, ratio):
    assert ratio <= 1
    return (pt1[0] + (ratio * (pt2[0] - pt1[0])), pt1[1] + (ratio * (pt2[1] - pt1[1])))
    
def triangle(s, h, c, inout):
    assert inout >= 0 and inout <= 1
    start = (-s/2, h/2)
    pivot = (0, h/2 - (c * 3))
    target = (s/2, h/2)
    control = interpolate((s/2, -c/2), (0, h/2 - c), inout)
    radius = s
    # optimal distance to control points is (4/3)*tan(pi/(2n); thank you https://stackoverflow.com/users/16673/suma for answering this question https://stackoverflow.com/questions/1734745/how-to-create-circle-with-b%C3%A9zier-curves
    control_ratio = ((4/3 * tan(pi/12)) * radius) / (2 * c)
    controlP = interpolate(pivot, control, control_ratio)
    controlT = interpolate(target, control, control_ratio)
    triangle = BezierPath()
    triangle.moveTo(start)
    triangle.lineTo(pivot)
    triangle.curveTo(controlP, controlT, target)
    triangle.closePath()
    drawPath(triangle)

def frame(x, y, m):
    f = BezierPath()
    g = BezierPath()
    f.rect(0, 0, x, y)
    g.rect(m, m, x - (2 * m), y - (2 * m))
    f = f.difference(g)
    f.closePath()
    drawPath(f)

# original Riley plan for Rustle 6    
plan = [
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0],
    [-1, 0, -1, 0, 0, 0, 0, 0, 1, 0, -1, 0, 0],
    [1, 0, 1, -1, 0, 0, -1, 0, 0, 0, 1, 0, 1, 0],
    [0, -1, 0, -1, 0, 0, 0, 1, 0, -1, 0, -1, 0],
    [0, 1, -1, 1, 0, 1, 0, 0, 0, 0, -1, 1, 0, 0],
    [-1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1],
    [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
    [0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0],
    [0, -1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, -1, 0],
    [-1, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1],
    [-1, 0, -1, 0, 1, 0, 1, 0, 0, 0, 1, -1, -1, 0],
    [0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, -1, 0],
    [0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    ]

for n in range(nFrames):
    newPage(canvasX, canvasY)
    frameDuration(1/30)
    ex = sin(radians(n * (360/nFrames)))
    fill(1)
    rect(0, 0, canvasX, canvasY)
    with savedState():
        translate(canvasX/2, canvasY/2)
        fill(0)
        translate(-(nX - 1) * offsetX/2, (nY - 1) * offsetY/2)
        for i in range(nY):
            with savedState():
                translate(0, i * -offsetY)
                if i % 2 == 0:
                    for j in range(nX - 1):
                        with savedState():
                            translate(offsetX/2 + (j * offsetX), 0)
                            triangle(side, height, center, .5 - (ex * (plan[i][j] * .5)))
                else:
                    for j in range(nX):
                        with savedState():
                            translate(j * offsetX, 0)
                            triangle(side, height, center, .5 - (ex * (plan[i][j] * .5)))
    fill(1)
    frame(canvasX, canvasY, side/2)

saveImage('~/Desktop/riley_tribute_test_01_%s.gif' %time)

The reference image:

I mean to do so at some point—probably on GitHub, probably this summer when I can take a little time to clean up code and organize the sketches.

And here's yet another—I forget the name of the illusion just now.

canvas = 500 #750
number = 15
shape = canvas/15
small = shape/2
offset = shape
nFrames = 90 #240
r = 5

def semi(pos, rot):
    s = BezierPath()
    if pos == 'top':
        s.arc((0, 0), shape/2, 0, 180, False)
    elif pos == 'bottom':
        s.arc((0, 0), shape/2, 0, 180, True)
    s.closePath()
    s.rotate(rot)
    drawPath(s)
    
for n in range(nFrames):
    newPage(canvas, canvas)
    frameDuration(1/30)
    fill(.85)
    rect(0, 0, canvas, canvas)
    translate(canvas/2, canvas/2)
    save()
    translate(-(number - 1) * offset/2, (number - 1) * offset/2)
    fill(.2)
    for i in range(number):
        save()
        translate(0, i * -offset)
        if (i % 2) == 0:
            v = 1
        elif (i % 2) == 1:
            v = -1
        for j in range(number):
            save()
            translate(j * offset, 0)
            if (j % 2) == 0:
                semi('top', r * (sin((2 * pi) * (n/nFrames))) * v)
            elif (j % 2) == 1:
                semi('bottom', r * (sin((2 * pi) * (n/nFrames))) * v)
            restore()
        restore()
    restore()
    translate(0, (number - 1) * offset/2)
    for i in range(number):
        save()
        translate(0, i * -offset)
        if (i % 2) == 0:
            fill(1)
            oval((cos((2 * pi) * (n/nFrames)) * canvas/2) - small/2, 0, small, small)
        elif (i % 2) == 1:
            fill(1)
            oval((cos((2 * pi) * (n/nFrames)) * -canvas/2) - small/2, 0, small, small)
        restore()
saveImage('~/Desktop/op_semi_lines.gif')

With both sketches, a larger canvas and more frames (240+) makes for a better effect.

Here's code for another, the 'intertwining illusion'.

canvas = 500
nFrames = 60 #240
size = canvas/36
num1 = 60
num2 = 44
num3 = 30
num4 = 14
r = 15

def mod(rot):
    m = BezierPath()
    m.rect(-size/2, -size/2, size, size)
    m.closePath()
    m.rotate(rot)
    drawPath(m)
    
for n in range(nFrames):
    newPage(canvas, canvas)
    frameDuration(1/30)
    fill(.5)
    rect(0, 0, canvas, canvas)
    strokeWidth(3)
    translate(canvas/2, canvas/2)
    save()
    for i in range(num1):
        if i % 2 == 0:
            stroke(1)
        else:
            stroke(.15)
        save()
        translate(.8 * canvas/2, 0)
        mod(r * (sin(2 * pi * n/nFrames)))
        restore()
        rotate(360/num1)
    restore()
    save()
    for j in range(num2):
        if j % 2 == 0:
            stroke(1)
        else:
            stroke(.15)
        save()
        translate(.6 * canvas/2, 0)
        mod(-r * (sin(2 * pi * n/nFrames)))
        restore()
        rotate(360/num2)    
    restore()
    save()
    for k in range(num3):
        if k % 2 == 0:
            stroke(1)
        else:
            stroke(.15)
        save()
        translate(.4 * canvas/2, 0)
        mod(r * (sin(2 * pi * n/nFrames)))
        restore()
        rotate(360/num3)    
    restore()
    save()
    for l in range(num4):
        if l % 2 == 0:
            stroke(1)
        else:
            stroke(.15)
        save()
        translate(.2 * canvas/2, 0)
        mod(-r * (sin(2 * pi * n/nFrames)))
        restore()
        rotate(360/num4)    
    restore()

saveImage('~/Desktop/opart_intertwine.gif')

The more frames, the more subtle the shift.

Good news about the pen functionality—glad I saw that, it'll come in handy for a couple things I'm working on …

@michelangelo Ned, please feel free to email me at maurice@mauricemeilleur.net. This is a bit of a specialty of mine.

Wim, thanks—as soon as I get a chance I'll see if this works for me. A potential problem is that I'll have polygons (not just triangles but squares, pentagons, etc) rotating, which means that any given shape in the larger figure will be interacting with multiple other shapes in changing ways.

Funny, not for me—can't find a package for NodeBox, and errors for nodebox-opengl and nodebox-color:

These are similar to the error I got and reported on PageBot's GitHub repo trying to install PageBot (or re-install it, since I thought we'd solved the problems I was having last October and I'd installed it successfully):

Collecting pagebot
  Using cached https://files.pythonhosted.org/packages/ce/b5/85ecaa46445effb02ea7e127aae95136a813bd44565d7a6f48e14989d64e/pagebot-0.9.3-py3-none-any.whl
Collecting booleanOperations
  Downloading https://files.pythonhosted.org/packages/fc/c6/c4cae54f482465a33c5f011d95ec64293dce9e012dac7873147c2dc85396/booleanOperations-0.9.0-py3-none-any.whl
Collecting tornado
  Using cached https://files.pythonhosted.org/packages/30/78/2d2823598496127b21423baffaa186b668f73cd91887fcef78b6eade136b/tornado-6.0.3.tar.gz
    ERROR: Command errored out with exit status 1:
     command: /Applications/DrawBot.app/Contents/MacOS/python -c 'import sys, setuptools, tokenize; sys.argv[0] = '"'"'/private/tmp/pip-install-anyjj7fg/tornado/setup.py'"'"'; __file__='"'"'/private/tmp/pip-install-anyjj7fg/tornado/setup.py'"'"';f=getattr(tokenize, '"'"'open'"'"', open)(__file__);code=f.read().replace('"'"'\r\n'"'"', '"'"'\n'"'"');f.close();exec(compile(code, __file__, '"'"'exec'"'"'))' --no-user-cfg egg_info --egg-base /private/tmp/pip-install-anyjj7fg/tornado/pip-egg-info
         cwd: /private/tmp/pip-install-anyjj7fg/tornado/
    Complete output (6 lines):
    Traceback (most recent call last):
      File "<string>", line 1, in <module>
      File "setuptools/__init__.pyc", line 20, in <module>
      File "setuptools/dist.pyc", line 30, in <module>
      File "setuptools/extern/__init__.pyc", line 61, in load_module
    ImportError: The 'packaging' package is required; normally this is bundled with this package so if you get this warning, consult the packager of your distribution.
    ----------------------------------------
ERROR: Command errored out with exit status 1: python setup.py egg_info Check the logs for full command output.

In case it's relevant, here is the result of the search:

Here's another one of those ‘if I knew Python better I'd know the answer already' questions, probably, but: what is this error message telling me, exactly?

@gferreira Thanks, Gustavo! I don't know how I've managed to go nearly four years without knowing this—I feel like I've used this method in the past to restore a reference. Lesson learned.

a = 1
b = [(a, a), (a + 1, a + 1)]

d = 1
g = b
print('original:', b, 'new, pending:', g)
c = [0, 1]
for n in c:
    g[n] = (g[n][0] - d, g[n][1] - d)
print('original:', b, 'new:', g)

returns:

original: [(1, 1), (2, 2)] new, pending: [(1, 1), (2, 2)]
original: [(0, 0), (1, 1)] new: [(0, 0), (1, 1)]

What is going on here? Why does changing g also change b?

@frederik Thanks (and thanks for opening this over in the GitHub repo). I'll give it a try later today. Speed isn't a factor in this case because I'm generating static diagrams.

I've been using DrawBot to generate diagrams—specifically, Boolean diagrams of categories with fuzzy boundaries—and I would love to see both linear and radial gradients incorporate an alpha channel.

I thought after I posted that pens would be part of a more elegant solution—my problem reminded me of some things Just has shown me, and I recall pens coming up in that conversation.

The fix I did find was to create a function that creates and returns a new path from the uncorrected path contour by contour and segment by segment, correcting points as needed by rounding to the nearest implied-grid increment. But now that classes are out I'll take the time to learn about pens (finally).

I'd still like to figure out why I was having the problem in the first place. At 1000pt the glyphs in Kast, my font I've been working with, are all exactly 692pt wide. With the proper linespacing and every other line offset 346pt (the width of the <space> glyph) all the points in adjacent glyphs horizontally and vertically should match exactly to allow me to combine their paths seamlessly.

Looking at the errors—maybe I'll put the analyses up in another post, I saved my test code—I felt like there was something about the formatted string that was introducing systematic misalignment, and removeOverlap() was also doing some math that threw off some points in the combined paths.

For reasons I can explain in detail if needed, I'd like to edit the oncurve points of a BezierPath before drawing the path, checking each point in turn to make sure its coordinates fall on an implied alignment grid and correcting it as needed.

Two methods that apparently don't work are:

for pt in path.onCurvePoints:
     if test(pt[0]) == Fail or test(pt[1]) == Fail:
          pt = (correctedCoordinate, correctedCoordinate)

and

for pt in range(len(path.onCurvePoints)):
     if test(path.onCurvePoints[pt][0]) == Fail or 
          test(path.onCurvePoints[pt][1]) == Fail:
          path.onCurvePoints[pt] = (correctedCoordinate, 
               correctedCoordinate)