back to noamberg.com

Back on track, and some OpenType wizardry revealed

April 17th, 2009 by Noam Berg

I got my computer back on Monday, restored all my data from the backup and got back to work. I scanned in the proofs from Bixler at 1200 DPI (in 8-bit grayscale, to cut down on file size). the results worked just fine in ScanFont. Speaking of which, the more I use ScanFont 5 the more I like it. In theory, you’re supposed to separate all the letters in your artwork so that they’re not overlapping each other’s bounding box. I didn’t bother this time, and Scanfont managed just fine. It even properly defined the sidebearings for he letter Q.

Caps in ScanFont 5

Lowercase in ScanFont 5

Q and sidebearings

With limited time ad hand and a presentation to put together, I put together four character sets from the proofs: upper and lowercase letters plus numbers and ampersand. I grafted in the punctuation from Christoffel Atlas, and programmed in auto ligatures and contextual alternates. I was able to get a behavior where the alts cycle through regardless of what letter is following: if it sees a preceding letter from set 1, it’ll use a letter from set 2, etc. This ended up mucking with my ligature code, for which I had to create classes instead of simple substitution. In plain English:

Fontlab lets you define classes when you’re programming OT features. Class in this context just means a group of characters (set, list, whatever you wanna call it). It looks something like this:

@Vowels.lc = [a e i o u];
@Vowels.uc = [A E I O U];
@Vowels = [@Vowels.lc @Vowels.uc y Y];

The @ symbol here is the syntax for defining a class, with the members of the class listed in the brackets. As you can see, a class can be composed of other classes for convenience. Set theory at its finest!

For doing contextual alternates, you create a class for each set of alternate characters. I have the sets @default, @calt1, @calt2 and @calt3. I write the calt (as in contextual alternate) feature so that whenever a character is encounters from @default, the next character will come from @calt1.the ‘ in the code means this is the anchor or target character, the one to be substituted depending on the context of those around it. So if two consecutive characters from @default show up, change the second one to the corresponding character from @calt1. If a character from @default is preceded by one from @calt1, change the target to @calt2. Finally, if a character from default it followed by one from @calt2, change the target to @calt3. You can do this for as many character sets as you have handy.

feature calt {
lookup rotate {
sub @default @default' by @calt1;
sub @calt1 @default' by @calt2;
sub @calt2 @default' by @calt3;
} rotate;


lookup rotate;
lookup rotate;
lookup rotate;
lookup rotate;
lookup rotate;

} calt;

For ligatures, you use a slightly different substitution scheme. You’re swapping two characters for one, regardless of the context. Simple ligature code looks like this:

feature liga {
sub f i by fi;
sub f l by fl;
sub f f by f_f;
sub f f i by f_f_i;
sub f f l by f_f_l;
} liga;

Simple enough. But when the calt routine has been swapping around your characters, it will break the above code. The solution is to define classes for ligatures:

@f = [f f.alt1 f.alt2 f.alt3];
@i = [i i.alt1 i.alt2 i.alt3];
@l = [l l.alt1 l.alt2 l.alt3];
@fi = [fi fi.alt1 fi.alt2 fi.alt3];
@fl = [fl fl.alt1 fl.alt2 fl.alt3];
@f_f = [f_f f_f.alt1 f_f.alt2 f_f.alt3];
@f_f_i = [f_f_i f_f_i.alt1 f_f_i.alt2 f_f_i.alt3];
@f_f_l = [f_f_l f_f_l.alt1 f_f_l.alt2 f_f_l.alt3];

Then modify the code:

feature liga {
sub @f @i by fi;
sub @f @l by fl;
sub @f @f by f_f;
sub @f @f @i by f_f_i;
sub @f @f @l by f_f_l;
} liga;

Now, instead of looking for the characters f and i when you want an fi ligature, you look for classes that contain them and all their relevant alternates. Problem solved.

Having all that in place, I used the resulting typeface to put together my presentation. I went for brevity whenever possible, but I knew there would be at least one critic who hasn’t seen my work before. When the slides were all assembled I did a run-through, timed it at 9 minutes (we were allotted 10) and went looking for my index cards.

The presentation itself, I’m happy to say, went off without a hitch. I brought along some books, the iRex iLiad reader I’ve been using, and the Bixler proofs as props. I think they complemented the presentation nicely, and the proofs especially were nice for getting across the tactility and physicality of letterpress that I’m trying to emulate. I got some good feedback from the critics, especially from Ethan, my writing instructor from last semester. He had very high praise for the work I’ve done, which meant an awful lot to me. My friend and classmate Alpay was kind enough to video the presentation for me, and I’ll be posting that as soon as I can convert it to a web-friendly format (as it is, I have a 1.58GB AVI file that’s too big for Vimeo). Also to come, the latest beta of Christoffel, with alt character sets.

Posted in Design, technology, Thesis, Typography

Leave a Comment

Please note: Comment moderation is enabled and may delay your comment. There is no need to resubmit your comment.

About the Mad Scientist Running this Show

Noam Berg is a graduate Student in the Design and Technology MFA program at Parsons School for Design in New York City. He is also the (debatably) creative force behind Exfish Studio. Noam is obsessed with old vacuum tubes, type design, computers, guitars and comic books. Noam likes Thai sweet chili sauce, hats, suits & ties, Wacom tablets, Japanese green tea (with the toasted rice), nerdy science girls, many varieties of music, SLR cameras, AnarchoJudaism, lithography and pocket watches. Noam's not a big fan of cell phones, the cool kids, ugly and over-used fonts (you know who you are!) and talking about himself in the third person. Seriously, this is really weird. I'm gonna stop doing it now.