- 3.6K All Categories
- 19 Introductions
- 2.8K Typeface Design
- 521 Font Technology
- 877 Technique and Theory
- 388 Type Business
- 362 Type Design Critiques
- 451 Type Design Software
- 29 Punchcutting
- 82 Lettering and Calligraphy
- 48 Technique and Theory
- 34 Lettering Critiques
- 317 Typography
- 218 History of Typography
- 87 Education
- 12 Resources
- 385 Announcements
- 61 Events
- 81 Job Postings
- 117 Type Releases
- 125 Miscellaneous News
- 204 About TypeDrawers
- 44 TypeDrawers Announcements
- 86 Suggestions and Bug Reports

## Comments

954For this I continue to make MM Type1 fonts and use Illustrator 10 which is the last version that supported MM sliders in the interface.

Alternatively I have created a massive list of instances that I can import into the Primary Instances section of the MM Settings in FontLab Font Info. I can then make a MMType1 font and test it in InDesign where each instance is listed in the font menu as a discreet weight/style. Seeing is believing.

642263Is it more so in the lightest weights where stem values are more true to their actual values? How far off of the actual stem measurements is it okay to stray?

905Yes.

739The way most type designers assign weights most of the time is a preference based on the art of not selecting a master size for a design, and not proofing it in conjunction with the other styles of the family, at all the sizes. Then picking a number of weights, as you read here, to fit the needs of a tyrannically bad sfnt table, carefully, or for no reason whatsoever, making sure there is enough weight between the weights to make it all look good at one size in a catalog.

This, I think, is art. Where it leads is often gruesome typography once the needs of specimens are left behind. Science starts with assigning a size, and determining the weight of regular at that size based on something... anything. It could be another regular of a family it must match. It could be the regular of a default font, for fallback to CJK in web use. Or, it could be the right compromise when preparing a regular weight to be used at a size across a variety of devices.

That is when assigning weights becomes not only interesting, but can be exacting enough for great looking typography, as we know from the past. While it is true that one may end up with 120 weights across a range of size masters and weights, and these are quite impossible to hook up to OS/2 values usefully, I don't think type technology should serve art alone.;)

1231,2826943I use the following variables:

t = thin value (20 in the example)

b = black value (220 in the example)

s = number of steps (9 in the example)

x = the step number (ranging from 1 to 9 in the example)

E = the interpolated value using equal steps

L = the interpolated value using Luc(as) Formula

I = the interpolated value using Impallari Formula

Then E is a linear function in x:

E = (b-t)/(s-1)*(x-1)+t

L is an exponential function in x:

L = t*(b/t)^((x-1)/(s-1))

I is a weighted average of E and L:

I = (x-1)/(s-1)*E+(s-x)/(s-1)*L

Altogether we get:

I = ((b * x^2) - ((2 * b) * x) + b + ((s^2 * t) * (b / t)^((x - 1) / (s - 1))) - (((s * t) * x) * (b / t)^((x - 1) / (s - 1))) + ((s * t) * x) - ((s * t) * (b / t)^((x - 1) / (s - 1))) - (t * x^2) - (s * t) + ((t * x) * (b / t)^((x - 1) / (s - 1))) + (t * x)) / (s^2 - (2 * s) + 1)

69436972Thanks @Linus Romer for the detailed explanations!

4054640I took it a step further (unfortunately only for RoboFont users - quick and dirty).

This script measures automatically the width of the first stem of a reference glyph (e.g. n) of 2 open fonts. (so no need to input values manually in the script).

The amount of steps has to be modified in the script as well as the reference glyph and the vertical-position of measurement.

As a second step it calculates the stem widths (based on Impallari and Luc).

The third step is the (invisible) interpolation until these values of stems are reached in order to get the interpolation factor(s) for all the stem widths. (see output screenshot)

This can take a while because it makes very small interpolation steps until it reaches the designated stem width.

The reference glyph in the 2 open fonts (e.g. n) has to be interpolatable!

Maybe this is helpful for some people.

No warranty. Not intensively tested yet.

1,07340121,0732517740https://github.com/luke-snider/family-stem-weights-calculator

I simplyfied the python scripts, which calculated the stem and interpolation values out of two .ufo files, in such a way that it now also works in GlyphsApp (font needs at least to masters).

One can either make the calculations by the 1st stem of a reference glyph (e.g "n") or simply provide values manually to get an output. (see OPTIONS in the script itself)

With the Drawbot Script (needs Drawbot of course) one has to provide values in the script itself to get a graph.

Maybe someone finds it useful.

@Jacques Le Bailly : I could be completely wrong of course, but maybe a (non-scientific) simple approach for serif typefaces could be to reduce the input-values of the thin and the black/bold by a certain percentage just for the calculation of the intermediate values on a curve.

Because serifs add weight to the stems the outcome of intermediate values should be maybe slightly lighter than in a Sans Serif.

But I guess it really depends on the design: The difference of the weight (thickness/angle etc.) of the serifs in a regular weight could be relatively low or relatively high.

Just my two cents.

40721,07377Now you are calculating within a range. Would it be possible to extrapolate values ? I am currently working on a typeface which in the end will be lighter and heavier than the existing masters. It would be useful to be able to test/experiment on values outside the range.

40Maybe someone else wants to contribute something?

43

Direct link to the executable JAR:

https://github.com/linusromer/stepinterpolation/blob/master/dist/stepinterpolation.jar