Just a very quick question I was hoping someone could answer...
I know that Mac OS X doesn’t make use of hinting, but do Adobe applications, which make use of their own rasterizers, use hints on the Mac?
I’ve tried comparing hinted and unhinted versions of the same glyphs in InDesign without noticing any differences, but unfortunately I don't have access to a non-retina display where those of us with failing eyesight might be more likely to spot differences.
André
0
Comments
Here are autohinted* (above) with unhinted (below) OTFs. InDesign CS6 8.0.2 on OSX 10.12.6 at Actual Size 100% view. 27-inch Apple LED Cinema Display.
Neither is stellar, but the point here is that there is a difference.
*(Only minimal StemSnapH and StemSnapV designated.)
To add confusion, some person or people decided to call and label the LCD-specific rendering mode "CoolType"... that was a painfully dumb move.
1. Gridfitting.
2. Rasterization.
In the first step, the glyph outline is modified (distorted). PostScript hints and TrueType instructions influence that distortion. Simply speaking, various distances between points that are similar in the original outline are actually equalized. Sometimes this means collapsing them to zero (so slightly convex or concave curves are transformed into straight lines), sometimes it's moving points so that all points along a stem or serif are aligned and the distances between points that are located at the opposite sides of a stem or serif are made equal across all glyphs.
20 years ago, gridfitting was done at real pixel-per-em sizes, so if type were to be rendered at 16 pixels per em, the contour points were all moved to sit exactly at the coarse grid of 16 "squares" per UPM size. And TrueType instructions would tell the renderer precisely: at 16 ppm, move this point here and that point there.
But now gridfitting is done differently. Whether it's Microsoft, Apple or Adobe, hints and instructions are used to gridfit the outline onto a much finer grid — often with differrent resolutions in X and Y. So if the font is rendered at 16 ppm, the gridfitting may be performed at a grid that is made of non-square rectangles of which there are 48 in the vertical and 224 in the horizontal. So the distortion still happens, but to a much smaller degree, because not the "16 ppm" instructions are executed but instead "48 ppm" instructions or "224 ppm" instructions.
Simply speaking, the font thinks it's being rendered in much larger size than it actually is, so the alignments and equalizations aren't as aggressive.
And then, once the renderer gets the gridfitted outline, it rasterizes it, i.e. projects the gridfitted outline onto a pixel map that is actually really the rectangle made of pixels that will be shown (so it may really be 16 ppm), but it uses complex antialiasing routines that colorize or grayscale the pixels differently if those pixels are near the gridfitted contour. Only pixels fully inside get the full color.
Or sometimes, they actually produce a rasterized monochrome bitmap at something like 48 or 224 ppm, and then use bitmap downsampling techniques with different sharpening and antialiasing filters (similar to how bitmap downsizing works in Photoshop).
The OS and app makers have been constantly refining both the gridfitting and the rasterization steps in their own renderers.
So the question is never "does it use hinting" but "how does it use hinting". Most modern apps and OSes still use hinting but differently than they used to.
The biggest difference is, in fact, in the gridfitting — the gridfitted outlines are being distorted to a much lesser degree than they used to. But also, more sophisticated ways to antialias the resulting bitmaps are being used.
In the early days, the antialiasing techniques that were used on fonts were specific to fonts. Today, they often use the same techniques as they use with normal vectors — but they still do gridfit *a bit*, which is why you can see the difference between hinted TT or PS glyphs and, say, SVG outlines.
“But now gridfitting is done differently.”
This has always been a three stage process, not two.
InDesign is widely used to produce e-Books or "interactive PDF"-style magazines, so the final type is often rendered in a browser or a PDF viewer.
Illustrator and Photoshop are widely used for prototyping and mocking up web or app user interfaces.
But also, designers who work in those tools often zoom out a lot (because their monitors are also filled with panels and UI elements of the app). So they often see the type in text columns much smaller than the final output will be (even if it is for print).
So in some environments, font-specific processes stop at the "supersampled gridfitting" stage, so a font rendering module such as FreeType is used only up to the stage of getting gridfitted vectors, and then those gridfitted vectors are passed into the compositing engine which them does it's own thing dealing with the entire composition of type and graphics. Antialiasing and filtering happens there ultimately, but it's no longer font-specific.
But there are other solutions where it is indeed a "font rasterizer" such as ClearType or FreeType that produces the final antialiased bitmaps.
And some environments do a combination: if the text is small size and perfectly horizontal, they use the font rasterizer fully, all the way to getting the final bitmaps, but if the text is large or rotated (e.g. on maps), they only get the vectors, sometimes even not gridfitted to any specific ppm.
Sizing in the process gets the font from upm to a ppm or to a super-ppm value, regardless of how, or how many times it does it, in preparation for scaling’s hinting. While not all fonts have hints, we all know what fonts with no hinting look like, and you don’t see those in the examples above, or most places. All other anti-aliased fonts are being rendered with some hinting, or hint-like substance.
So, e.g if folks want to really helpful, iduuno maybe instead of “It (Adobe Cooltype), has multiple options and modes, though, so it's not like a single thing that produces just one result”,
...get to bottom of it, if it’s an issue. If all things are equal then it does produce the one result, and if the results are unequal this is because something has changed.
Some Adobe apps e.g. offer Type Rendering Options, they have names, like SHARP, these Type Rendering Options. Type Rendering Options do or don’t resize or rescale the font depending on which rendering occurs!? Start at the user end, work your way back to the font maker end, string that friggin’ maze... toolmaker.:)