Hinting and OS X

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é

Comments

  • Kent LewKent Lew Posts: 796
    Seems to me like it has an effect.

    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.)
  • Thanks. There I can clearly see the difference.
  • To judge hinting on a retina screen, set the type really tiny (like 5pt) and then use the screen zoom from macOS to enlarge it. Make sure that you disable the ‘enhancement’. 
  • Thomas PhinneyThomas Phinney Posts: 1,112
    Yes, Adobe apps use the hinting built into fonts. Adobe has their own rasterizers, used by most of their apps. CoolType is the most common of the Adobe rasterizers, and is used by the major desktop apps (InDesign, Illustrator, Photoshop). It has multiple options and modes, though, so it's not like a single thing that produces just one result.
  • Also, if you copy your generated fonts to "/Library/Application Support/Adobe/Fonts" they will update while the Adobe program remains open. So you can have a InDesign document with text, export the font from your editor, and switch back to InDesign and see the refreshed font without having to restart the program. Based on that you will notice hinting updates when you keep zoom levels the same and update a particular glyph to check.
  • Mike DugganMike Duggan Posts: 166
    just musing, I wonder about the value of the Adobe apps using hinting, when the eventual output is to the Web or print. How much content is consumed in the Apps, InDesign for instance? or is it useful for proofreading? 
  • The closer Adobe app rasterizers come to the look of the final outputs, the easier it is to make good decisions about type size, weight, and tracking.
  • Mike DugganMike Duggan Posts: 166
    yes true if the hinting is for output to Windows, mostly? and if its the same hinting that will show up in the final output. all output for Mac will be unhinted. like I said just musing :)

  • Mark SimonsonMark Simonson Posts: 955
    edited January 11
    I would prefer the Mac OS font rendering in Adobe apps, or at least an option to use it. On the other hand, if something is seriously wrong with the hinting, it does let you see it.
  • Mike DugganMike Duggan Posts: 166
    if using a TT Hinted font such as Calibri for example or any TT Hinted font, do the Adobe apps show you the TT Hinting exactly as Hinted, or something else? 
  • To judge hinting on a retina screen, set the type really tiny (like 5pt) and then use the screen zoom from macOS to enlarge it. Make sure that you disable the ‘enhancement’. 
    What do you mean by disabling 'enhancements'?
  • if using a TT Hinted font such as Calibri for example or any TT Hinted font, do the Adobe apps show you the TT Hinting exactly as Hinted, or something else? 
    Is does show TrueType hints in some kind of greyscale mode.
  • Thomas PhinneyThomas Phinney Posts: 1,112
    Adobe uses the hinting built into the font, but just as Microsoft has several radically different rasterizing schemes, Adobe has their own rasterizer doing its thing. Adobe's CoolType has LCD and b&w modes, and has been improved over time.

    To add confusion, some person or people decided to call and label the LCD-specific rendering mode "CoolType"... that was a painfully dumb move.
  • There are two fundamental steps to screen type rendering:

    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. 
  • Waaaait a minute.

    “But now gridfitting is done differently.”

    This has always been a three stage process, not two. 

  • just musing, I wonder about the value of the Adobe apps using hinting, when the eventual output is to the Web or print. How much content is consumed in the Apps, InDesign for instance? or is it useful for proofreading? 
    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). 
  • Waaaait a minute.

    “But now gridfitting is done differently.”

    This has always been a three stage process, not two. 
    I have tried to give a very simplified account of how this works, no accuracy guaranteed. Please feel free to extend/amend! 
  • Adam TwardochAdam Twardoch Posts: 397
    edited January 19
    AFAIK, it used to be so that after gridfitting, a monochrome bitmap was always produced, and then filtering/antialiasing happened. But today, this isn't always the case because type rendering often happens in the same pipeline as other vector assets using a variety of "vector backends" like OpenGL, Vulkan, Quartz, Metal, whatever.

    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. 
  • Adam I think you’re saying that there is a sizing of some sort going on, but you’re not listing it among the two things :-) As Mike Reed explained it to me, long time ago,  sizing, scaling, and rendering are fairly basic parts that I don’t think any of the solutions can skip.

    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.:) 
Sign In or Register to comment.