I am working on a typeface and not looking forward to the idea of redesigning each glyph for every single weight, so I'm very interested in generating some of the weights using multiple masters in FontLab.

How does this generally work? I read the chapter in the FL manual and it seems that the best way to do it is:

1) Create a regular weight

2) Create "extremes", for instance, "Ultra Thin" and "Ultra Black".

3) Interpolate the intermediate forms, like Thin, Light, Bold, Black, etc.

Is this how it's generally done? Are most typeface families created from these three weights? Also, are the results acceptable if you're interpolating something across a wide range, such as an interpolation between a regular weight and an "Ultra Black" weight? Or should the extremes be closer together?

Lastly, I want at least three weights-- light, regular and bold. I'd imagine that in this case, MM can't help me, as I would need at least these three weights before I could do any interpolation anyway. The only other way would be using extrapolation, but I don't trust the results of that particular technique for my font weights.

I’m also looking for any good references on interpolation techniques, Fontlab-centric or otherwise.

http://superpolator.com/movies/SuperpolatorScreencast_intro_small.mov

. . .

Bert Vanderveen BNO

Yes, the Thin--Regular--Ultra system works for me.

Extrapolation is marginally useful.

Other than that--experiment! You don't need a whole font, just make a few letters and see what happens.

If you want three weights, it makes sense to have Hairline and Ultra as the extremes, rather than Light and Bold, because you will then be able to make those anyway, and interpolation is far better than extrapolation. And for a sans, Hairline is quite easy--just draw a path (using your Regular in the mask layer as a guide) and give it a stroke value of 20.

A related thread is http://typophile.com/node/39239 (Design forum), with a great post by Carl Crossgrove.

You may find this interesting. Or useful. Or totally confusing.

Totally confusing, Tim, but interesting. I'm having a little trouble imagining how it would be applied, i.e. what the results would look like in an actual glyph. But I love this statement:

These three diagrams are different interpretations or manifestations of the same phenomenon. Just like a thrown object describes a parabola in real space as well as in a path-space diagram.This is a real world example:

This is assuming a manually designed extralight (XL), regular (REG) and extrabold (XB) exist, otherwise my system cannot be applied.

If we want to generate a semibold (SB) we can do so by extrapolating from XL 'across' REG, as seen on the left. However, the horizontal bar is too heavy for this weight since it is (almost) proportional in both the source weights.

In the XB the bar is tweaked very much, which finds its way into the interpolated SB, as seen on the right: the horizontal is too heavy, and also the overall weight.

What we want is something in between: part extrapolation and part interpolation. This can be achieved by adjusting the weights in our cocktail that gives the semibold. I typically put the three weights into an MM font (which means, unfortunately, that two masters are identical) and then calculate the required MM positions to give the desired resulting weight, and amount of extra- vs interpolation. Note that in the above example the fact that there is exactly 100% REG is random, it could be more or less than that.

This may all seem complicated and the improvements are not drastic. However, it amost does not cause any additional work – all you have to do is to combine your weights a bit differently when you generate the weights you do not design manually. It is my experience that the time you save for correcting the semibold outweighs (ha ha) the effort to set up the MM font.

http://www.lucasfonts.com/index_neu.html

>information > interpolation theory

The LucasFont idea is this: all the formulas boil down to saying that b, the width of the "medial" stem, is the square root of the product of a by c, where a is the smallest and c the largest stem. This means that the width of the medium stem is the geometric mean of the widths of the smallest and largest stems. This is equivalent to saying that the logarithm of b is exactly the arithmetic mean of the logarithm of a and that of c. This is logarithmic interpolation and this looks interesting. My feeling is that Tim's interpolation uses a quadratic fit (whence the parabola). Am I wrong? Tim, would it make any sense to mix the two approaches (i.e. take a log, use a quadratic fit, and then exponentiate)?

Michel

[edit 1] Maybe the method should rather be called "exponential interpolation". I can find no reference for the moment.

[edit 2] Yes, it should be called exponential interpolation as can be found here.

As someone pointed out in another thread, a simple way of stating Lucas's idea is that the weights should be a geometric progression: the ratio of each term (weight) to the previous one is the same. For example, if you have three successively heavy weights, A,B,C, then algebraically A/B = B/C. Rearranging you get Lucas's formula: AC = B^2 . In a talk I saw him give, he explained a more complex version that takes into account double and triple horizontal strokes, but I don't remember it.

> Lucas’s idea is that the weights should be a geometric progression

This is exactly why they can be made to fit an exponential curve.

My feeling is that Tim’s interpolation uses a quadratic fit.

Note that my diagrams are in different spaces than Lucas's. My approach does not say anything about the weight of the individual instances, it considers only the interpolation. By choosing the amounts of the three ingredients (which means two degrees of freedom) you can create any graph you want. All I am saying is that it should not have kinks. A pure interpolation with a kink is a special case in my approach.

Yes, it should be called exponential interpolation

No, it should be called geometric sequence or progression (see http://en.wikipedia.org/wiki/Geometric_sequence). This is precisely what it is, nothing more and nothing less. You can transform that into complicated formulas if you want, of course, but they will not say anything else.

Lucas's concept is about the individual weights – despite the name it does not say anything about interpolation, actually.

> You can transform that into complicated formulas if you want, of course, but they will not say anything else.

I agree with your statement. However, if the smallest stem is a, the largest is c, and if you have 5 weights between a and c, then according to Lucas the stem of weights k=1 to 5 is a*(c/a)**(k/6.0) using Python code. The explanation in terms of geometric progression is nice but does not give Python code.

[edit] I meant according to the formula y(x) = y0*(y1/y0)**x; here y0 = a, y1 = c; x is k/6 where k=0 for stem a and k=6 for stem c and k from 1 to 5 gives those in between.

If you take the formula on Geometric Progression in Wikipedia, you can also write a*r**k for k from 1 to 5 with r = (c/a)**(1.0/6). Both approaches are indeed equivalent; the advantage of the formula in http://music.nuim.ie/musictec/docs/progr/interpolation.pdf is that it is expressed as an interpolation formula.

The important thing to decide is how many instances you have between the lightest and the fattest.

You want to be very careful to avoid an instance where the stem width and the width between stems is identical.

That can happen if you have, say, x number of instances, but x+1 or x-1 will avoid it. However, then you have to consider another priority: you should have Regular and Bold work well together and look like Regular and Bold, not Regular and Extra Bold or Light and Medium.

I just want to say that I’ve been playing with the MM features in Fontlab based on the comments in this thread, the Fontlab manual, and Adobe’s

Designing Multiple Master Typefaces.This is so awesome and easy it’s scary. And it’s fun, too.

You want to be very careful to avoid an instance where the stem width and the width between stems is identical.I don't think I've ever heard this rule before. It's not hard to find examples of classic foundry typefaces where this is true for some characters, so I must say I'm a bit skeptical. Where does this idea come from and what's the reason for it?

I wouldn't say it's a rule, just an observation and a recommendation.

There's something disconcerting about evenly matched values in a figure-ground relationship, because the eye is not quite sure which is which.

So I think it makes sense, when you're picking where to place your instances on the curve, to avoid that situation.

Here are two typeface examples of adjacent weights, Helvetica and Univers, which straddle the equivalent instance.

I haven't done a survey, but I suspect this is typical.

The general idea is that while a multiple master curve offers infinite choices, there are scales of visually-pleasing instances which restrict what is practical.

Moderators, please

doremove spam.Member for1 hour 22 min

... and then already kicked out. Tsk, tsk.

If you notice spam please report it to the moderators. Thanks. :)

I am researching this topic for use in a future business I am thinking about starting. Thank you for this information, it has been educational and helpful to me. Web Site