# Family Stem Weights Calculator

## Comments

#### Categories

- All Categories
- 40 Introductions
- 3.6K Typeface Design
- 781 Font Technology
- 1K Technique and Theory
- 602 Type Business
- 437 Type Design Critiques
- 530 Type Design Software
- 30 Punchcutting
- 135 Lettering and Calligraphy
- 82 Technique and Theory
- 53 Lettering Critiques
- 470 Typography
- 295 History of Typography
- 112 Education
- 63 Resources
- 485 Announcements
- 76 Events
- 105 Job Postings
- 147 Type Releases
- 156 Miscellaneous News
- 265 About TypeDrawers
- 53 TypeDrawers Announcements
- 113 Suggestions and Bug Reports

0670265Is 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?

909Yes.

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

1331,45818543I 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)

1854318572Thanks @Linus Romer for the detailed explanations!

4064240I 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,42140121,4212628840https://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.

40741,42188Now 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