mercoledì 4 aprile 2007

Expand Stroke

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:

boot ha detto...

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

Anonimo ha detto...

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

Manuel Colombo ha detto...

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.

boot ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

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

Anonimo ha detto...

...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

mattjakob ha detto...
Questo commento è stato eliminato dall'autore.
mattjakob ha detto...
Questo commento è stato eliminato dall'autore.
mattjakob ha detto...
Questo commento è stato eliminato dall'autore.
mattjakob ha detto...

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

dimitre ha detto...

Hello, do you know some way to expand stroke "fl.CallCommand(33622)" without prompt?