Questo è lo script che può servirvi per dare un corpo al vostro scheletro
#inizio codice
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622)
#fine codice
aggiungetelo alla fine come per il codice nel post precedente
16 commenti:
Ecco il mio primo esperimento
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
h=asta+l*2
l=400
asta=200
asta2=asta/6
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,l/2))
pen.qCurveTo((l,0),(l/2,0))
pen.qCurveTo((0,0),(0,l/2))
pen.lineTo((0,l/2+asta))
pen.qCurveTo((0,asta+l),(l/2,asta+l))
pen.qCurveTo((l,asta+l),(l,l/2+asta))
pen.lineTo((l,l/2+asta-asta2))
pen.closePath()
g.update()
#inizio codice
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622)
#fine codice
C'è un errore nella definizione delle variabili. Devi prima definire "asta" per poterla usare in "h". Facendo leggergli prima h, lui non sa cosa hai definito con asta e dà errore
Questo è il mio primo esperimento, ho usato solo impostazioni di altezza e larghezza, e come finale la variabile v (variazione) per definire il modo di uscita del tracciare la lettera.
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=400
h=800
v=150
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,h))
pen.qCurveTo((0,h),(0,h/2))
pen.qCurveTo((0,0),(l/2,0))
pen.qCurveTo((l,0),(l+v,v))
pen.closePath()
g.update()
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
Fede, non ho capito perchè definisci la variabile h se poi non la usi mai.
Sì in effetti non la uso, cmq fa capire che l'altezza del glifo è data dalla lunghezza dell'asta + 2 volte la larghezza del glifo
partendo dai vostri codici ho provato a fare questo ma ho dei problemi con le curve...e non capisco il significato della terza variabile (v)
la C mi viene spigolosa perchè esplicito tutti i punti...ma non capisco come fare altrimenti
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=400
h=800
v=300#ma va bene qualsiasi numero!!!!!!!!
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,h/4))
pen.qCurveTo((l,h/4),(l/2,0))
pen.qCurveTo((l/2,0),(0,h/4))
pen.qCurveTo((0,h/4),(0,h*3/4))
pen.qCurveTo((0,h*3/4),(l/2,h))
pen.qCurveTo((l/2,h),(l,h*3/4))
pen.closePath()
g.update()
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
Io ho usato un approccio diverso: mi sono concentrato sui punti di controllo rifacendomi alle equazioni delle rette.
Il codice è grezzo e presenta dei problemi (i valori delle variabili hanno dei limiti), ma a modo suo funziona.
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = font['C']
#inserisco i miei parametri
x=800 #dimensione 100<=x<=10000
a=0 #stretch verticale -1<=a<=1.3
b=0 #inclinazione -100<=b<=130
c=100 #stretch orizzontale -70<=c<=100
#creo nuovi parametri dai precedenti
x1=8*x/10
x2=4*x/10
x3=6*x/10
x4=1.1*x
y1=(a+1.2)*x1+20
y2=(a+1.2)/1.4*x2+10
y3=(a+1.2)/20*x3+5
y4=(a+1.2)/10*x4+2.5
b1=b/2+(c*1.25)
b2=b*2+(c*4)
b3=b*3+(c*2.3)
b4=b3-b/3-(c*3.5)
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((x1*1.35+c,y1/1.1))
pen.qCurveTo((x1-b1,y1),(x2-b2,y2),(x3-b3,y3),(x4-b4,y4))
pen.closePath()
g.update()
#inizio codice
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622)
#fine codice
per semplicità ho pensato ad una C ottenuta con una sola curva di Bezier, però di terzo grado
il codice è questo:
#c ottenuta come un unica curva di bezier di terzo grado( 2 punti estremi più due punti di controllo)
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=300
h=800
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,0))
pen.qCurveTo((l,0),(-250,h/6),(-250,h*5/6),(l,h))
pen.closePath()
g.update()
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
poi ho provato a pensarla come fatta da più curve quadratiche, credo di aver fatto più o meno lo stesso ragionamento di Fede...
#C creata solo con bezier quadratiche...stesso ragionamento di Fede
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=400
h=700
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,h*2/7))
pen.qCurveTo((l,h*2/7),(l,0),(l/2,0))
pen.qCurveTo((l/2,0),(0,0),(0,h*2/7))
pen.lineTo((0,h*5/7))
pen.qCurveTo((0,h*5/7),(0,h),(l/2,h))
pen.qCurveTo((l/2,h),(l,h),(l,h*5/7))
pen.closePath()
g.update()
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
il mio problema è comunque quello di capire dove vanno i punti di controllo...per adesso vado a caso aiutandomi con disegnini...non so se è il ragionamento corretto
Io l'ho fatta così
import robofab.world
from robofab.world import *
glifo = CurrentGlyph()
pen = glifo.getPen()
x=300
y=400
a=300
b=150
c=100
d=2 * b
e=3 * b
f=e - c
g=c + 50
pen.moveTo((x,y))
pen.curveTo((x - a,y - b),(x - a,y - d),(x,y - e))
pen.lineTo((x, y - f))
pen.curveTo((x - g, y - d),(x - g, y - b),(x, y - c))
pen.closePath()
glifo.update()
ciao
ho fatto cosi la lettera c
i punti di controllo si trovano sull'assis y'y e l=h
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=500
h=l
#pulisco lo schermo
g.clear()
#inizio a disegnare
#punti di controllo su y assis e l=h
pen=g.getPen()
pen.moveTo((l,0))
pen.qCurveTo((l,0),(0,-l/5),(0,h),(3*l/5,h))
pen.closePath()
g.update()
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
ecco la nostra C
#C quasi tonda, fatta da tre curve quadratiche e poi ruotata
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=400
p=l/40
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,l/2))
pen.qCurveTo((l-p,p),(l/2,0))
pen.qCurveTo((p,p),(0,l/2))
pen.qCurveTo((p,l-p),(l/2,l))
pen.closePath()
g.update()
g.rotate((-45))
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
...eccone un'altra
#C ancora più tonda...ma abbiamo usato le bezier di terzo grado...quindi abbiamo barato!
#inizio del codice
#esercitazione1: disegno della c parametrica
import robofab
from robofab.world import *
font = CurrentFont()
g = CurrentGlyph()
#inserisco i miei parametri
l=400
p=l*5/16
#pulisco lo schermo
g.clear()
#inizio a disegnare usando i parametri sopra definiti
pen=g.getPen()
pen.moveTo((l,l/2))
pen.qCurveTo((l,p),(l-p,0),(l/2,0))
pen.qCurveTo((p,0),(0,p),(0,l/2))
pen.qCurveTo((0,l-p),(p,l),(l/2,l))
pen.closePath()
g.update()
g.rotate((-45))
#inizio codice vedi scheletro
g = fl.iglyph
glifo = fl.font.glyphs[g]
fl.EditGlyph()
fl.CallCommand(40156)
glifo[glifo.nodes_number-1].selected = 1
fl.CallCommand(32812)
fl.CallCommand(33622) #disegna col pennino
#fine codice
CHI HA DETTO CHE GLI 80s SONO FINITI ?!?!
io l'altra volta non c'ero (emh) e non so bene cosa vi sia venuto in mente di fare... Se si tratta di disegnare una C con dei parametri, questa è la mia :-D
sweep : determina quanto gira il tracciato della C (piu o meno aperta)
freq : determina il numero di pixels che la compone
Non ho usato le funzioni (bi) quadratiche dato che altri miei compagni ne hanno già fatto degli esempi.
# DECLARATIONS------------------------------------------------------------------------
import robofab
from robofab.world import *
import math
font = CurrentFont()
glyph = CurrentGlyph()
# PARAMETERS--------------------------------------------------------------------------
radius = 400 # 'c' radius
pix = 40 # squares size
sweep = 250 # angle drawn
freq = 20 # subdivisions
size = ((radius * 2) + (pix * 2)) * 1.1 # overall image size
Cx = Cy = size /2
# DRAWING-----------------------------------------------------------------------------
glyph.clear()
pen=glyph.getPen()
stepAngle = (float(sweep) / freq) # rotation at each loop
rAmount = (360-sweep)/2 # amount to add in order to have the 'c' aligned
print "--- pixie C ---" # used just for debug
def drawRect(pen, x, y, size=pix): # function to draw a single 'pix'
pen.moveTo((x-.5*size, y-.5*size))
pen.lineTo((x+.5*size, y-.5*size))
pen.lineTo((x+.5*size, y+.5*size))
pen.lineTo((x-.5*size, y+.5*size))
pen.closePath()
while freq > 0:
angle = rAmount + stepAngle * freq
print angle
x = radius * math.cos(angle*(math.pi/180))
y = radius * math.sin(angle*(math.pi/180))
drawRect(pen, Cx + x, Cy + y)
freq = freq - 1
glyph.update()
PS: Se fate copia/incolla dal sito probabilmente python vi da errore perche mancano gli spazi ad inizio riga che definiscono i blocchi 'while' e 'def'.
Se volete potete scaricare lo script da qui: http://uploadhut.com/view.php/457613.py
Hello, do you know some way to expand stroke "fl.CallCommand(33622)" without prompt?
Posta un commento