@rohernandezz You don’t have ~/Library/Preferences/com.drawbot.plist ?

Almost the same code, but instead of drawing a grid we draw 1000 circles randomly. As they have to stay in the same place, we save their locations in an array.

(Also in this script some nice code to have if you want to publish animated gifs; a way to reduce the colours in the gif.)

import random
import struct

frames = 24
page_size = 1000
number_of_circles = 1000
min_dot_size = 10
max_dot_size = 70
radius = 200


# create color table for gif
# https://stackoverflow.com/questions/6269765/what-does-the-b-character-do-in-front-of-a-string-literal
table = b""
greys = [0,85,170,255]
for i in greys:
    r = struct.pack(">B", i)
    g = struct.pack(">B", i)
    b = struct.pack(">B", i)
    table += r + g + b # + a


def draw_dot(center, diameter): 
    x = center[0] - diameter / 2
    y = center[1] - diameter / 2
    oval(x, y, diameter, diameter)


# Generate circles, randomly distributed
circles = []
for i in range(number_of_circles):
    x = random.randint(0,page_size)
    y = random.randint(0,page_size)
    circles.append((x,y))


for f in range(frames):
    percentage_animated = f / frames
    newPage()
    
    fill(0)
    rect(0, 0, page_size, page_size)

    for c in circles:
        x = c[0]
        y = c[1]
        distance = pow( (pow(x - page_size / 2, 2 ) + pow(y - page_size / 2, 2)), 0.5)
        distance = distance - percentage_animated * radius * 2
        distance = distance % (radius * 2)
        percentage = distance / radius
        if percentage > 1:
            percentage = 2 - percentage
        dot_size = min_dot_size + percentage * (max_dot_size - min_dot_size)
        fill(None)
        stroke(1)
        draw_dot((x,y), dot_size)
        
saveImage("animated.gif", imageGIFRGBColorTable = table)

frames = 24
page_size = 1000
grid_size = 20
grid_spacing = page_size / grid_size
min_dot_size = 10
max_dot_size = 50
radius = 100

def draw_dot(center, diameter): 
    x = center[0] - diameter / 2
    y = center[1] - diameter / 2
    oval(x, y, diameter, diameter)

for f in range(frames):
    percentage_animated = f / frames
    newPage()
    
    fill(0)
    rect(0, 0, page_size, page_size)

    for row in range(grid_size):
        for column in range(grid_size):
            x = row * grid_spacing + grid_spacing / 2
            y = column * grid_spacing + grid_spacing / 2
            # Calculate distance from (x,y) of the dot to the center of the page
            distance = pow( (pow(x - page_size / 2, 2 ) + pow(y - page_size / 2, 2)), 0.5)
            # The wave must seem to move, so for every frame in the 
            # animation, add a precentage of the length of the wave.
            # Add or substract to change direction.
            distance = distance - percentage_animated * radius * 2
            # Use modulo to get a distance between 0 and double the radius
            distance = distance % (radius * 2)
            # The wave has a lenghth of double the radius. In the 
            # first halve of the lenght, the dots get larger, in the 
            # second halve the dots get smaller.
            # So, we calculate a percentage between 0 and 2, and when
            # the percentage is larger than 1, we count backwards.
            percentage = distance / radius
            if percentage > 1:
                percentage = 2 - percentage
            dot_size = min_dot_size + percentage * (max_dot_size - min_dot_size)
            fill(1)
            draw_dot((x,y), dot_size)
        
saveImage("animated.gif")

radius = 300
circle_size = 300
step = 3
x, y = 500, 500

fill(1)
stroke(0)

for d in range(0, 360, step):
    circle1 = BezierPath()
    circle1.oval(x - circle_size / 2, y - circle_size / 2, circle_size, circle_size)
    circle1.translate(0, radius)
    circle1.rotate(d, (x, y))

    circle2 = BezierPath()
    circle2.oval(x - circle_size / 2, y - circle_size / 2, circle_size, circle_size)
    circle2.translate(0, radius)
    circle2.rotate(d + step, (x, y))
    
    dif = circle2.difference(circle1)
    drawPath(dif)

In response to https://twitter.com/MauriceMeilleur/status/1242196482717110274

This will make an animated gif with two frames, one frame with text, the other without, thus creating the illusion of flashing text.

w = 500
h = 500

newPage(w,h)
# Draw a black background
fill(0)
rect(0, 0, w, h)
# Draw gray text
fill(0.2)
font("Times-Italic", 190)
text("FLASH", (w/2, h/2), align="center")

newPage(w,h)
# Draw a black background
fill(0)
rect(0, 0, width(), height())

saveImage("rapid flashing.gif")

@pi That is exactly my solution. It’s not elegant, but it’s quick and it works.

Below is the Applescript I used. If you name your paths in Illustrator and put the names in pathNames it will copy the coordinates of the points and corresponding control points to an array you can paste in DrawBot.

on run
	set pathNames to {"segment_concave"}
	set pathsArray to "segment = ["
	
	tell application "Adobe Illustrator"
		activate
		set docRef to current document
		
		repeat with pathName in pathNames
			set pointsArray to "["
			set itemRef to path item pathName of docRef
			
			set pointsRef to every path point of itemRef
			repeat with pointRef in pointsRef
				-- anchor point
				set pointAsString to "["
				set x to my string_float(item 1 of anchor of pointRef)
				set y to my string_float(item 2 of anchor of pointRef)
				set pointAsString to pointAsString & "(" & x & "," & y & "), "
				
				-- left bcp
				set x to my string_float(item 1 of left direction of pointRef)
				set y to my string_float(item 2 of left direction of pointRef)
				set pointAsString to pointAsString & "(" & x & "," & y & "), "
				
				-- right bcp
				set x to my string_float(item 1 of right direction of pointRef)
				set y to my string_float(item 2 of right direction of pointRef)
				set pointAsString to pointAsString & "(" & x & "," & y & ")"
				
				set pointAsString to pointAsString & "]"
				set pointsArray to pointsArray & pointAsString & ", "
			end repeat
			set pointsArrayLength to length of pointsArray
			set pointsArray to (characters 1 through (pointsArrayLength - 2) of pointsArray) as string
			set pointsArray to pointsArray & "]"
			
			set pathsArray to pathsArray & pointsArray & ", "
		end repeat
		set pathsArrayLength to length of pathsArray
		set pathsArray to (characters 1 through (pathsArrayLength - 2) of pathsArray) as string
		set pathsArray to pathsArray & "]"
		
	end tell
	
	activate
	set the clipboard to pathsArray
	log pathsArray
end run



on string_float(s)
	set s to s as string
	set new_s to ""
	repeat with c in s
		if c as string is equal to "," then set c to "."
		set new_s to new_s & c as string
	end repeat
	return new_s
end string_float

Almost the same code, but instead of drawing a grid we draw 1000 circles randomly. As they have to stay in the same place, we save their locations in an array.

(Also in this script some nice code to have if you want to publish animated gifs; a way to reduce the colours in the gif.)

import random
import struct

frames = 24
page_size = 1000
number_of_circles = 1000
min_dot_size = 10
max_dot_size = 70
radius = 200


# create color table for gif
# https://stackoverflow.com/questions/6269765/what-does-the-b-character-do-in-front-of-a-string-literal
table = b""
greys = [0,85,170,255]
for i in greys:
    r = struct.pack(">B", i)
    g = struct.pack(">B", i)
    b = struct.pack(">B", i)
    table += r + g + b # + a


def draw_dot(center, diameter): 
    x = center[0] - diameter / 2
    y = center[1] - diameter / 2
    oval(x, y, diameter, diameter)


# Generate circles, randomly distributed
circles = []
for i in range(number_of_circles):
    x = random.randint(0,page_size)
    y = random.randint(0,page_size)
    circles.append((x,y))


for f in range(frames):
    percentage_animated = f / frames
    newPage()
    
    fill(0)
    rect(0, 0, page_size, page_size)

    for c in circles:
        x = c[0]
        y = c[1]
        distance = pow( (pow(x - page_size / 2, 2 ) + pow(y - page_size / 2, 2)), 0.5)
        distance = distance - percentage_animated * radius * 2
        distance = distance % (radius * 2)
        percentage = distance / radius
        if percentage > 1:
            percentage = 2 - percentage
        dot_size = min_dot_size + percentage * (max_dot_size - min_dot_size)
        fill(None)
        stroke(1)
        draw_dot((x,y), dot_size)
        
saveImage("animated.gif", imageGIFRGBColorTable = table)

frames = 24
page_size = 1000
grid_size = 20
grid_spacing = page_size / grid_size
min_dot_size = 10
max_dot_size = 50
radius = 100

def draw_dot(center, diameter): 
    x = center[0] - diameter / 2
    y = center[1] - diameter / 2
    oval(x, y, diameter, diameter)

for f in range(frames):
    percentage_animated = f / frames
    newPage()
    
    fill(0)
    rect(0, 0, page_size, page_size)

    for row in range(grid_size):
        for column in range(grid_size):
            x = row * grid_spacing + grid_spacing / 2
            y = column * grid_spacing + grid_spacing / 2
            # Calculate distance from (x,y) of the dot to the center of the page
            distance = pow( (pow(x - page_size / 2, 2 ) + pow(y - page_size / 2, 2)), 0.5)
            # The wave must seem to move, so for every frame in the 
            # animation, add a precentage of the length of the wave.
            # Add or substract to change direction.
            distance = distance - percentage_animated * radius * 2
            # Use modulo to get a distance between 0 and double the radius
            distance = distance % (radius * 2)
            # The wave has a lenghth of double the radius. In the 
            # first halve of the lenght, the dots get larger, in the 
            # second halve the dots get smaller.
            # So, we calculate a percentage between 0 and 2, and when
            # the percentage is larger than 1, we count backwards.
            percentage = distance / radius
            if percentage > 1:
                percentage = 2 - percentage
            dot_size = min_dot_size + percentage * (max_dot_size - min_dot_size)
            fill(1)
            draw_dot((x,y), dot_size)
        
saveImage("animated.gif")

A simple example of how to move the wave through a grid of dots. The position of the dots does not matter.

@frederik probably has a better and more robust solution for this also

2. I don’t think you need a radial grid.

If you base the timing of the animation of one hexagon on its distance to the center point, I believe you get the same effect as in your example.

1. Changing the bezier-handle is a simple as calculating a point between two extremes, based on a percentage, based on how far you are in your animation.

(Check out easings.net to create smoother animations)

frames = 12

def draw_segment(percentage):
    first_point = (-500, 0)
    first_control_point_convex = (-500, 185.191467285156)
    first_control_point_concave = (-350.388183585986, 86.410583482659)
    second_control_point_convex = (-399.316345214836, 346.863525390625)
    second_control_point_concave = (-249.704528786313,248.082641579087)
    second_point = (-249.704528808587, 433.274108886719)
    # Calculate in-between points based on percentage
    fcpcx = first_control_point_convex[0] + percentage * (first_control_point_concave[0] - first_control_point_convex[0])
    fcpcy = first_control_point_convex[1] + percentage * (first_control_point_concave[1] - first_control_point_convex[1])
    scpcx = second_control_point_convex[0] + percentage * (second_control_point_concave[0] - second_control_point_convex[0])
    scpcy = second_control_point_convex[1] + percentage * (second_control_point_concave[1] - second_control_point_convex[1])
    first_control_point = (fcpcx, fcpcy)
    second_control_point = (scpcx, scpcy)
    # Make and draw path
    bez = BezierPath()
    bez.moveTo(first_point)
    bez.curveTo(first_control_point, second_control_point, second_point)
    drawPath(bez)

def draw_hexagon(percentage):
    for i in range(6):
        with savedState():
            translate(500,500)
            scale(0.5, 0.5)
            rotate(i * 60, center=(0, 0))
            draw_segment(percentage)

for i in range(frames):
    newPage()

    fill(None)
    stroke(0)
    strokeWidth(10)

    percentage = i / frames
    draw_hexagon(percentage)

for i in range(frames, 0, -1):
    newPage()

    fill(None)
    stroke(0)
    strokeWidth(10)

    percentage = i / frames
    draw_hexagon(percentage)

saveImage("animated.gif")

1. Without doing too much math, and using some ugly constants, you can draw a segment of the hexagon.

Draw and rotate it six times, and you have the basis of the hexagon.

def draw_segment():
    # Coordinates based on a circle with diameter 1000 and center at 0,0
    first_point = (-500, 0)
    first_control_point = (-500, 185.191467285156)
    second_control_point = (-399.316345214836, 346.863525390625)
    second_point = (-249.704528808587, 433.274108886719)
    # Make and draw path
    bez = BezierPath()
    bez.moveTo(first_point)
    bez.curveTo(first_control_point, second_control_point, second_point)
    drawPath(bez)

def draw_hexagon():
    for i in range(6):
        with savedState():
            translate(500,500)
            scale(0.5, 0.5)
            rotate(i * 60, center=(0, 0))
            draw_segment()

newPage()

fill(None)
stroke(0)
strokeWidth(10)
draw_hexagon()