@gferreira Thank you! I've used this in the following application but I noticed that even though I used hyphenation=False the words break in the middle so, I don't need it to break for this exercise but it's something I can't figure out:

myVarFont = '/Library/Application Support/Adobe/Fonts/AstripeVariableGX.ttf'
variations = listFontVariations(myVarFont)
print(variations)
axis1 = list(variations.keys())[0]
minH = variations[axis1]['minValue']
maxH = variations[axis1]['maxValue']
axis2 = list(variations.keys())[1]
minV = variations[axis2]['minValue']
maxV = variations[axis2]['maxValue']

#Words
def textPage(*words, o=0, size='Tabloid', positive=True, h=True, txt=FormattedString(), myFont=myVarFont, fSize=30, lHeight=23.5):
    def canvas():
        newPage(size)
        if positive is True:
            fill(1)
        if positive is False:
            fill(0)
        rect(o, o, width(), height())
    canvas()
    txt.font( installFont(myFont) )
    txt.fontSize(fSize)
    txt.openTypeFeatures(calt=True)
    txt.lineHeight(lHeight)
    hyphenation(False)
    lineLength = 0
    textLength = (width()*height())/(lHeight)
    #print(textLength)
    
    while txt.size()[0] < textLength:
        for word in words:
            if lineLength % 350 == 0:
                txt.append('\n' + word, fontVariations={axis1:minH, axis2:minV})
            else:    
                txt.append(word, fontVariations={axis1:minH, axis2:minV})
            lineLength += textSize(word)[0]
            #print(lineLength)
    textBox(txt, ( o, o, width(), height() ))
    #print(txt.size()[0])
    
     
textPage('PIBA', '2020', 'LIDERA')

saveImage('~/Desktop/PIBA_2020_CORBATA.pdf')

This is what I need from the image:

And this is what I don't understand:

By the way:
The previous exercise worked this way:

import os

import unicodedata
def strip_accents(text):
    try:
        text = unicode(text, 'utf-8')
    except NameError: # unicode is a default on python 3 
        pass
    text = unicodedata.normalize('NFD', text)\
           .encode('ascii', 'ignore')\
           .decode("utf-8")
    return str(text)

class Canvas:
    def __init__(self, w, h, o = 0, bleed = 0):
        self.w = w
        self.h = h
        self.o = o
        self.bleed = bleed
        if self.bleed <= 0:
            newPage(self.w, self.h)
        else:
            newPage(self.w + self.bleed * 2, self.h + self.bleed * 2)
            translate(self.bleed, self.bleed)
    def color(self, r = 255, g = 255, b = 255, a = 100):
        self.r = r / 255
        self.g = g / 255
        self.b = b / 255
        self.a = a / 100
        return fill(self.r, self.g, self.b, self.a)
    def bg_stroke(self, r, g, b, a, sw):
        self.r, self.g, self.b, self.a = color_c(r, g, b, a)
        self.sw = sw
        stroke(self.r, self.g, self.b, self.a)
        strokeWidth(self.sw)
        fill(None)
    def grid(self, cols, rows, gutter, mTop, mBottom, mLeft, mRight, view=True):
        if view == True:
            self.cols = cols
            self.rows = rows
            self.gutter = gutter
            self.mTop = mTop - self.gutter
            self.mBottom = mBottom  - self.gutter
            self.mLeft = mLeft - self.gutter
            self.mRight = mRight - self.gutter
            wd = (self.w - self.gutter * (self.cols + 1)) / self.cols - ((self.mRight + self.mLeft) / self.cols)
            hg = (self.h - self.gutter * (self.rows + 1)) / self.rows - ((self.mTop + self.mBottom) / self.rows)
            fill(None)
            strokeWidth(0.25)
            stroke(0, 1, 1)
            for self.col in range(self.cols):
                for self.row in range(self.rows):
                    x = self.gutter + self.col * (wd + self.gutter)
                    y = self.gutter + self.row * (hg + self.gutter)
                    rect(x + self.mLeft, y + self.mBottom, wd, hg)
    def bg_square(self):
        if self.bleed <= 0:
            rect(self.o, self.o, self.w, self.h)
        else:
            rect(self.o - self.bleed, self.o - self.bleed, self.w + self.bleed * 2, self.h + self.bleed * 2)
    def bg_image(self, imgPath, px, py, angle, s):
        self.imgPath = imgPath
        self.px = px
        self.py = py
        self.angle = angle
        self.s = s
        srcWidth, srcHeight = imageSize(self.imgPath)
        dstWidth, dstHeight = self.w + s, self.h + s
        factorWidth = dstWidth  / srcWidth
        factorHeight = dstHeight / srcHeight
        with savedState():
            scale(factorWidth, factorHeight)
            rotate(self.angle)
            translate(self.px, self.py)
            image(imgPath, (0, 0))
    def crop_marks(self):
        stroke(1)
        strokeWidth(1)
        line((self.o, -8), (self.o, -4))
        line((-8, self.o), (-4, self.o))
        line((self.o + self.w, -8), (self.o + self.w, -4))
        line((8 + self.w, self.o), (4 + self.w, self.o))
        line((self.o, 8 + self.h), (self.o, 4 + self.h))
        line((-8, self.o + self.h), (-4, self.o + self.h))
        line((self.o + self.w, 8 + self.h), (self.o + self.w, 4 + self.h))
        line((8 + self.w, self.o + self.h), (4 + self.w, self.o + self.h))
        stroke(0)
        strokeWidth(0.5)
        line((self.o, -8), (self.o, -4))
        line((-8, self.o), (-4, self.o))
        line((self.o + self.w, -8), (self.o + self.w, -4))
        line((8 + self.w, self.o), (4 + self.w, self.o))
        line((self.o, 8 + self.h), (self.o, 4 + self.h))
        line((-8, self.o + self.h), (-4, self.o + self.h))
        line((self.o + self.w, 8 + self.h), (self.o + self.w, 4 + self.h))
        line((8 + self.w, self.o + self.h), (4 + self.w, self.o + self.h))
            
#Design

#Margin
gutter = 0
mTop = 8
mBottom = 8
mLeft = 8
mRight = 8

#Variable Font
myVarFont = '/Library/Application Support/Adobe/Fonts/AstripeVariableGX.ttf'
variations = listFontVariations(myVarFont)
print(variations)
#print(listFontGlyphNames())
axis1 = list(variations.keys())[0]
minH = variations[axis1]['minValue']
maxH = variations[axis1]['maxValue']
axis2 = list(variations.keys())[1]
minV = variations[axis2]['minValue']
maxV = variations[axis2]['maxValue']
num = 0
logo = 'PIBA_2020_GAFETES_LOGO.pdf'

#Info
gafetes_dir = {'Staff': 3, 'All Access': 1, 'Participante': 3, 'Prensa': 1, 'Académico': 3, 'Maestro de Ceremonia': 3, 'Jueces': 1, 'Edecán': 1, 'Sistemas': 1, 'Acompañante': 1, 'Director': 1} 

gafetes = [i for i in gafetes_dir.keys()]
copias = [i for i in gafetes_dir.values()]

def gafete(gf=0):
    #Frente
    page = Canvas(240, 150, 0, 8)
    page.color(255, 255, 255, 100)
    page.bg_square()
    
    #Text
    var = 400
    minus = 0
    lineHeight = 45
    al = 'right'
    fs = 41
    
    t = FormattedString()
    t.font(installFont(myVarFont))
    t.fontSize(fs)
    t.fill(0)
    t.openTypeFeatures(calt=True)
    t.align(al)
    t.lineHeight(lineHeight)
    t.baselineShift(-15)
    
    for letter in gafetes[gf].upper():
        t.append(letter, fontVariations={axis1:var, axis2:randint(minV, maxV)})
    print(t.size()[0])
    
    while t.size()[0] < page.w - 40 and var < 500:
        var += 10
    print(var)
    
    if t.size()[0] > 300.0:
        lineHeight = 40
        minus = 440.0
        print('minus')
        
    if t.size()[0] < 140.0:
        lineHeight = 69
        fs = 60
        print('minus')
    
    t = FormattedString()
    t.font(installFont(myVarFont))
    t.fontSize(fs)
    t.fill(0)
    t.openTypeFeatures(calt=True)
    t.align(al)
    t.lineHeight(lineHeight)
    t.baselineShift(-15)
    for letter in gafetes[gf].upper():
        t.append(letter, fontVariations={axis1:var, axis2:randint(minV, maxV - minus)})
    textBox(t, (mLeft, mBottom, page.w - mRight - mLeft, page.h - mTop - mBottom))
    
    #Art
    page.bg_image('/Users/eduardo.aire/Documents/Documentos - EATs iMac/A/01_A_PROYECTOS/01_VIGENTES/2020_PIBA/PIBA_2020_FOTOS/29_PIBA_2020_ESTELASTRIPE.psd', -1140, -10, 270, 100)
    
    #Marks, guides and comments 
    #fill(0, 0, 0, 0.1)
    #rect(mLeft, mBottom, page.w - mRight - mLeft, page.h - mTop - mBottom)
    page.crop_marks()
    page.grid(6, 3, 0, mTop, mBottom, mLeft, mRight, False)
    
    #Reverso
    page = Canvas(240, 150, 0, 8)
    page.color(255, 255, 255, 100)
    page.bg_square()   
    
    #Logo
    imgPath = logo
    srcWidth, srcHeight = imageSize(imgPath)
    dstWidth, dstHeight = page.w, page.h
    factorWidth = dstWidth  / srcWidth
    factorHeight = dstHeight / srcHeight
    with savedState():
        scale(1)
        rotate(-90)
        translate(-150, 0)
        image(imgPath, (0,0))
    
    #Marks, guides and comments 
    #fill(0, 0, 0, 0.1)
    #rect(mLeft, mBottom, page.w - mRight - mLeft, page.h - mTop - mBottom)
    page.crop_marks()
    page.grid(6, 3, 0, mTop, mBottom, mLeft, mRight, False)
    
    saveImage('~/Desktop/PIBA_2020_GAFETES_{name}_{number:0>2}.pdf'.format(name = strip_accents(gafetes[gf].upper().replace(" ", "_")), number = str(num)))
    newDrawing()

#gafete(6)

for i in range(len(gafetes)+1):
     num=1
     for j in range(copias[i - 1]):
         gafete(i - 1)
         num += 1

Hi!

I'm making some id cards for a project and I want to control the words' horizontal interpolation, so I think I need to identify when a word is about to break and at that moment stop adding interpolation, in the same way when a text jumps to the other line I want to control vertical interpolation so I want to know if there's a way to identify a line jumps.

Here's the code:

import os
import unicodedata

def strip_accents(text):

    try:
        text = unicode(text, 'utf-8')
    except NameError: # unicode is a default on python 3 
        pass

    text = unicodedata.normalize('NFD', text)\
           .encode('ascii', 'ignore')\
           .decode("utf-8")

    return str(text)

class Canvas:
    
    def __init__(self, w, h, o = 0, bleed = 0):
        self.w = w
        self.h = h
        self.o = o
        self.bleed = bleed
        if self.bleed <= 0:
            newPage(self.w, self.h)
        else:
            newPage(self.w + self.bleed * 2, self.h + self.bleed * 2)
            translate(self.bleed, self.bleed)
    
    def color(self, r = 255, g = 255, b = 255, a = 100):
        self.r = r / 255
        self.g = g / 255
        self.b = b / 255
        self.a = a / 100
        return fill(self.r, self.g, self.b, self.a)
    
    def bg_stroke(self, r, g, b, a, sw):
        self.r, self.g, self.b, self.a = color_c(r, g, b, a)
        self.sw = sw
        stroke(self.r, self.g, self.b, self.a)
        strokeWidth(self.sw)
        fill(None)
    
    def grid(self, cols, rows, gutter, mTop, mBottom, mLeft, mRight, view=True):
        if view == True:
            self.cols = cols
            self.rows = rows
            self.gutter = gutter
            self.mTop = mTop - self.gutter
            self.mBottom = mBottom  - self.gutter
            self.mLeft = mLeft - self.gutter
            self.mRight = mRight - self.gutter
            wd = (self.w - self.gutter * (self.cols + 1)) / self.cols - ((self.mRight + self.mLeft) / self.cols)
            hg = (self.h - self.gutter * (self.rows + 1)) / self.rows - ((self.mTop + self.mBottom) / self.rows)
            fill(None)
            strokeWidth(0.25)
            stroke(0, 1, 1)
            for self.col in range(self.cols):
                for self.row in range(self.rows):
                    x = self.gutter + self.col * (wd + self.gutter)
                    y = self.gutter + self.row * (hg + self.gutter)
                    rect(x + self.mLeft, y + self.mBottom, wd, hg)
    
    def bg_square(self):
        if self.bleed <= 0:
            rect(self.o, self.o, self.w, self.h)
        else:
            rect(self.o - self.bleed, self.o - self.bleed, self.w + self.bleed * 2, self.h + self.bleed * 2)
    
    def bg_image(self, imgPath, px, py, angle, s):
        self.imgPath = imgPath
        self.px = px
        self.py = py
        self.angle = angle
        self.s = s
        srcWidth, srcHeight = imageSize(self.imgPath)
        dstWidth, dstHeight = self.w + s, self.h + s
        factorWidth = dstWidth  / srcWidth
        factorHeight = dstHeight / srcHeight
        with savedState():
            scale(factorWidth, factorHeight)
            rotate(self.angle)
            translate(self.px, self.py)
            image(imgPath, (0, 0))
    
    def crop_marks(self):
        stroke(1)
        strokeWidth(1)
        line((self.o, -8), (self.o, -4))
        line((-8, self.o), (-4, self.o))
        line((self.o + self.w, -8), (self.o + self.w, -4))
        line((8 + self.w, self.o), (4 + self.w, self.o))
        line((self.o, 8 + self.h), (self.o, 4 + self.h))
        line((-8, self.o + self.h), (-4, self.o + self.h))
        line((self.o + self.w, 8 + self.h), (self.o + self.w, 4 + self.h))
        line((8 + self.w, self.o + self.h), (4 + self.w, self.o + self.h))
        stroke(0)
        strokeWidth(0.5)
        line((self.o, -8), (self.o, -4))
        line((-8, self.o), (-4, self.o))
        line((self.o + self.w, -8), (self.o + self.w, -4))
        line((8 + self.w, self.o), (4 + self.w, self.o))
        line((self.o, 8 + self.h), (self.o, 4 + self.h))
        line((-8, self.o + self.h), (-4, self.o + self.h))
        line((self.o + self.w, 8 + self.h), (self.o + self.w, 4 + self.h))
        line((8 + self.w, self.o + self.h), (4 + self.w, self.o + self.h))
            
#Design

#Margin
gutter = 0
mTop = 8
mBottom = 8
mLeft = 8
mRight = 8

#Variable Font
myVarFont = '/Library/Application Support/Adobe/Fonts/AstripeVariableGX.ttf'
variations = listFontVariations(myVarFont)
print(variations)
#print(listFontGlyphNames())
axis1 = list(variations.keys())[0]
minH = variations[axis1]['minValue']
maxH = variations[axis1]['maxValue']
axis2 = list(variations.keys())[1]



minV = variations[axis2]['minValue']
maxV = variations[axis2]['maxValue']
fs = 41
gf = 7

def lenght():
    var = 400
    var += 200
    return var

#Canvas
page = Canvas(240, 150, 0, 8)
page.color(255, 255, 255, 100)
page.bg_square()

#Info
gafetes = ['Staff', 'All Access', 'Participante', 'Prensa', 'Académico', 'Maestro de Ceremonia', 'Jueces', 'Edecán', 'Sistemas', 'Acompañante', 'Director']    

#Art
page.bg_image('/Users/eduardo.aire/Documents/Documentos - EATs iMac/A/01_A_PROYECTOS/01_VIGENTES/2020_PIBA/PIBA_2020_FOTOS/29_PIBA_2020_ESTELASTRIPE.psd', -1160, -70, 270, 110)
t = FormattedString()
t.font(installFont('/Library/Application Support/Adobe/Fonts/AstripeVariableGX.ttf'))
t.fontSize(fs)
t.fill(0)
t.openTypeFeatures(calt=True)
t.align('right')
hyphenation(True)
t.lineHeight(45)
t.baselineShift(-15)
for letter in gafetes[gf].upper():
    t.append(letter, fontVariations={axis1:lenght(), axis2:randint(minV, maxV)})
textBox(t, (mLeft, mBottom, page.w - mRight - mLeft, page.h - mTop - mBottom))

#Marks, guides and comments
#fill(0, 0, 0, 0.1)
#rect(mLeft, mBottom, page.w - mRight - mLeft, page.h - mTop - mBottom)
page.crop_marks()
page.grid(6, 3, 0, mTop, mBottom, mLeft, mRight, False)

#Saving
saveImage('~/Desktop/PIBA_2020_GAFETES_{name}.png'.format(name = strip_accents(gafetes[gf].upper().replace(" ", "_"))), imageResolution = 144)

And here some images of the design.

Thank you!!

Great!!!

Thank you very much, I'll play with it and I'll share the result.

Cheers!

@frederik thank you very much. I think my explanation was wrong, what I'm looking for is for a way to control the Easy Ease speed.

Hi everyone, I'm trying to generate multiple gifs with a typeface I've created, here's the code:

#Variable Font
myVarFont = '/Users/user/Documents/folder/variablefont.ttf'

variations = listFontVariations(myVarFont)

#print(variations)

steps = 24
minH, maxH = 60, 90

axis1 = list(variations.keys())[0]
minH = variations[axis1]['minValue']
maxH = variations[axis1]['maxValue']

axis2 = list(variations.keys())[1]
minV = variations[axis2]['minValue']
maxV = variations[axis2]['maxValue']

#stepH = (maxH - minH) / (steps - 1) # Horizontal variation
stepV = (maxV - minV) / (steps - 1) # Vertical variation

#Color converter
def color_c(r = 255, g = 255, b = 255, a = 100):
    rc = r / 255
    gc = g / 255
    bc = b / 255
    ac = a / 100
    return rc, gc, bc, ac

#Creating canvas and background
class Canvas:
    
    def __init__(self, w, h, o = 0):
        self.w = w
        self.h = h
        self.o = o
        newPage(self.w, self.h)
    
    def bg_fill(self, r, g, b, a):
        self.r, self.g, self.b, self.a = color_c(r, g, b, a)
        fill(self.r, self.g, self.b, self.a)
    
    def bg_stroke(self, r, g, b, a, sw):
        self.r, self.g, self.b, self.a = color_c(r, g, b, a)
        self.sw = sw
        stroke(self.r, self.g, self.b, self.a)
        strokeWidth(self.sw)
        fill(None)
    
    def wrks(self):
        rect(self.o, self.o, self.w, self.h)
    
    def stroke_rep(self, step, first, jump=0):
        self.step = step
        self.first = first
        plus = self.first + jump
        translate(0, 0)
        for i in range(self.step):
            rect((width() / 2) - (plus / 2), (height() / 2) - (plus / 2), plus + jump, plus + jump)
            plus += self.sw * 4
    
    def bg_image(self, imgPath = None):
        self.imgPath = imgPath
        self.srcWidth, self.srcHeight = imageSize(self.imgPath)
        self.dstWidth, self.dstHeight = self.w, self.h
        self.factorWidth  = self.dstWidth  / self.srcWidth
        self.factorHeight = self.dstHeight / self.srcHeight
        with savedState():
            scale(factorWidth, factorHeight)
            image(imgPath, (self.o, self.o))
            
#Start design
concursos = ["LH", "AT", "INM", "SB", "Mat", "Dec", "T-A", "LT", "TS", "BC", "CEI", "CV", "CL", "Deb", "ICM", "MUN", "TLA", "Rob"]
          
def art(txt):
    
    for i in range((steps * 2) - 2):
        
        page = Canvas(500, 500, 0)
        page.bg_fill(255, 255, 255, 100)
        page.wrks()

        if i < steps:
            #H = minH + i * stepH
            V = minV + i * stepV
        else:
            #H = maxH - ((i % steps) + 1) * stepH
            V = maxV - ((i % steps) + 1) * stepV
        
        #print(i, V)
    
        w = (width() - 40) / len(txt)
        save()
        translate(20, 50)
    
        #stepH_ = (maxH - minH) / (len(txt))
        stepV_ = (maxV - minV) / (len(txt))

        T = FormattedString()
        T.fontSize(300)
        T.font(myVarFont)
    
        for j, char in enumerate(txt):

            #H_ = H + j * stepH_
            V_ = V + j * stepV_
        
            #if H_ > maxH:  H_ -= (maxH - minH)
            if V_ > maxV:  V_ -= (maxV - minV)
        
            T.append(char, fill=(0), fontVariations={axis1:100, axis2:V_})

            translate(w * 1, 0)
        
            #H_ += stepH_
            V_ += stepV_

        restore()
        text(T, (width() / 2, (height() / 4)), align='center')
    
        page.bg_stroke(255, 255, 255, 100, 110)
        page.wrks()
        for i in range(8):
            page.bg_stroke(0, 0, 0, 100, 8.9)
            page.stroke_rep(i + 5,  384)
    
    saveImage('~/Desktop/PIBA_2020_CATEGORIAS_{name}.gif'.format(name = txt))
    
f = 0
while f < len(concursos):        
     art(concursos[f])
      newDrawing()
     f += 1

Is there a way to make a smoother animation with the same number of frames?

Thanks!!

import string
import random

# path to the image
path = u"https://yourimage.jpg"

# get the size of the image
print(imageSize("https://yourimage.jpg"))

# w, h = imageSize(path) s = letter size
w = 400
h = 400
s = 10

# Set the characters you need
chars = 'HOLAhola'
print (random.choice(chars))

# Get colors
pix_cols = {}
for x in range(0, w, s):
    for y in range(0, h, s):
        pix_cols[(x, y)] = imagePixelColor(path, (x, y))
        
# Variable font to use       
"""
FontName
wdth {'name': 'Width', 'minValue': 100.0, 'maxValue': 800.0, 'defaultValue': 100.0}
wght {'name': 'Weight', 'minValue': 150.0, 'maxValue': 800.0, 'defaultValue': 150.0}
slnt {'name': 'Slant', 'minValue': 0.0, 'maxValue': 14.0, 'defaultValue': 0.0}
"""

min_val_wdth = listFontVariations('FontName')['wdth']['minValue']
max_val_wdth = listFontVariations('FontName')['wdth']['maxValue']
min_val_wght = listFontVariations('FontName')['wght']['minValue']
max_val_wght = listFontVariations('FontName')['wght']['maxValue']
min_val_slnt = listFontVariations('FontName')['slnt']['minValue']
max_val_slnt = listFontVariations('FontName')['slnt']['maxValue']

def ranLetters():
    # loop over the width of the image    
    newPage(w, h)
    fill(1)
    rect(0, 0, w, h)
    
    for x in range(0, w, s):
        # loop of the height of the image
        for y in range(0, h, s):
            color = pix_cols[(x, y)]
            if color:
                txt = random.choice(chars)
                font("FontName")
                fontSize(s)
                
                fontVariations(wdth = randint(min_val_wdth, max_val_wdth), wght = randint(min_val_wght, max_val_wght))

                r, g, b, a = color
                # set the color
                fill(r, g, b, a)
                # draw some text
                text(txt, (x, y), align='center')
                
for i in range(5):
    ranLetters()
            
saveImage("~/Desktop/name.gif", imageResolution=144)

@jo Thank you very much for the help! I think I don't really know how the translate function works, I'll take a look on it later, by the way, you solved my problem, the only thing that never worked is the font outside the loop, I don't know why. Thanks!!!

Hi, I’m playing with variable fonts and images, I have two questions, how can I use just some characters, and which could be a better way to write the code, because it takes so long to render the gif and it always appears a firs blank page. Thank you all!

import string
import random

# path to the image
path = u"https://scontent.fmex6-1.fna.fbcdn.net/v/t1.0-9/42516210_1195851967229695_2595517735622410240_n.png?_nc_cat=103&_nc_oc=AQlcHYpbwrz7YCN-WPr0rUxI4-Glqu4ug8Oua-UKqAe-oQXGVyYMunKNOWrxKscDWMk&_nc_ht=scontent.fmex6-1.fna&oh=6bb9b894653113271e6cac9b723e4d81&oe=5E63F271"

# get the size of the image
print(imageSize("https://scontent.fmex6-1.fna.fbcdn.net/v/t1.0-9/42516210_1195851967229695_2595517735622410240_n.png?_nc_cat=103&_nc_oc=AQlcHYpbwrz7YCN-WPr0rUxI4-Glqu4ug8Oua-UKqAe-oQXGVyYMunKNOWrxKscDWMk&_nc_ht=scontent.fmex6-1.fna&oh=6bb9b894653113271e6cac9b723e4d81&oe=5E63F271"))

# w, h = imageSize(path)
w = 1656
h = 1656

# shift it up a bit
translate(0, 2)

min_val = listFontVariations('League Spartan Variable')['wght']['minValue']
max_val = listFontVariations('League Spartan Variable')['wght']['maxValue']

# setup a variable for the font size as for the steps
s = 10
w = 560    
h = 560

def ranLetters():
    # loop over the width of the image    
    newPage(w, h)
    fill(randint(0, 1))
    rect(0, 0, w, h)
    for x in range(0, w, s):
        # loop of the height of the image
        for y in range(0, h, s):
            # get the color            
            color = imagePixelColor(path, (x, y))
            if color:
                font("League Spartan Variable")
                fontSize(s)
                lineHeight(s * 0.75)
                txt = random.choice(string.ascii_letters)
            
                fontVariations(wght = randint(min_val, max_val))
            
                r, g, b, a = color
                # set the color
                fill(r, g, b, a)
                # draw some text
                text(txt, (x, y))
                
for i in range(10):
    ranLetters()
            
saveImage("~/Desktop/ee.gif")

@gferreira wow, this is huge!!! thank you again

@gferreira it worked, thanks a lot, I want to know if there’s a way to control the speed of the animation?.

def drawShape(step):
   
    jumpinValue = 0
    thickness = 3
    
    fill(None)
    strokeWidth(thickness)
    stroke(0)
    fill(None)
    
    translate(0, 0)

    for i in range(step):
        oval((width()/2) - (jumpinValue*3), (height()/2)-(jumpinValue*3), 10+(jumpinValue*4), 10+(jumpinValue*4))
        translate(thickness, thickness)
        jumpinValue += thickness

# create pages/frames
for i in range(150):
    newPage(1000, 1000)
    fill(1)
    rect(0, 0, 1000, 1000)
    drawShape(i+1)
    

# save animation
saveImage('~/Desktop/radial.mp4')