Truetype vs Type 1 hinting
Dr Thomas Conway
I have a question about hinting.
The Type 1 font hinting scheme as I understand it, provides a
mechanism for declaring properties of the font (cap height, etc)
and properties of characters (the location of stems) in a high
level kind of way that leaves the details of producing accurate
renderings to the rendering engine.
By contrast, my (more limited) understanding of TrueType hinting
is that much more information about the rendering environment
is provided to the font program to allow it to render itself
better at the given resolution/offset.
I welcome any corrections of my understanding.
If this is the case, then Type 1 seems to be "better" in as much
as it relies on the type designer to accurately describe his
intent (capital letters should be *this* high, a vertical stem
goes *here*, etc), and depends on the rendering engine to use
this information cleverly. You improve the engine, and the
rendering of *all* your fonts improves. By contrast, you end
up effectively writing your own hinting on every character in
a TrueType font. Not only does this sound inefficient (more work
in the interpreted code of the font), but it also requires you
to write your hinting code to work consistently on every character.
This sounds like a short term win because you can spend lots of
effort building a few core fonts to render well, but requires a
lot more effort in the long run, because you have to repeat the
work for every font. On the other hand, you can probably get away
with a simpler rendering engine.
Does this reflect the real situation? How good are the Type 1
hinting engines? If I were to design a new font, should I go
for Type 1 or TrueType?
Thomas
--
Dr Thomas Conway )O+
<con...@mds.rmit.edu.au> 499 User error! Replace user, and press any
key.
Apostrophe (')
"Dr Thomas Conway" <con...@mds.rmit.edu.au> wrote in message
news:3d65...@itsawnews.its.rmit.edu.au...
>
> The Type 1 font hinting scheme as I understand it, provides a
> mechanism for declaring properties of the font (cap height, etc)
> and properties of characters (the location of stems) in a high
> level kind of way that leaves the details of producing accurate
> renderings to the rendering engine.
>
> By contrast, my (more limited) understanding of TrueType hinting
> is that much more information about the rendering environment
> is provided to the font program to allow it to render itself
> better at the given resolution/offset.
>
This is very true. I've always wondered about that myself. How in the world
did we end up in such a mess when it comes to hinting? We could easily be
using type 1 fonts for screen, thereby eliminating any possibility of screen
font monopoly, since hinting type 1 fonts is so much simpler than hinting
true type. I suppose it may have something to do with decent postscript
rasterizers never having shipped with operating systems until very recently,
and now the user's screen font mentality is too far gone into the true type
scheme to be repaired.
George N. White III
> Hi
> I have a question about hinting.
>
> The Type 1 font hinting scheme as I understand it, provides a
> mechanism for declaring properties of the font (cap height, etc)
> and properties of characters (the location of stems) in a high
> level kind of way that leaves the details of producing accurate
> renderings to the rendering engine.
>
> By contrast, my (more limited) understanding of TrueType hinting
> is that much more information about the rendering environment
> is provided to the font program to allow it to render itself
> better at the given resolution/offset.
>
> I welcome any corrections of my understanding.
This is consistent with what I have read.
> If this is the case, then Type 1 seems to be "better" in as much
> as it relies on the type designer to accurately describe his
> intent (capital letters should be *this* high, a vertical stem
> goes *here*, etc), and depends on the rendering engine to use
> this information cleverly. You improve the engine, and the
> rendering of *all* your fonts improves. By contrast, you end
> up effectively writing your own hinting on every character in
> a TrueType font. Not only does this sound inefficient (more work
> in the interpreted code of the font), but it also requires you
> to write your hinting code to work consistently on every character.
> This sounds like a short term win because you can spend lots of
> effort building a few core fonts to render well, but requires a
> lot more effort in the long run, because you have to repeat the
> work for every font. On the other hand, you can probably get away
> with a simpler rendering engine.
>
> Does this reflect the real situation? How good are the Type 1
> hinting engines? If I were to design a new font, should I go
> for Type 1 or TrueType?
I'm not sure this reasoning applies, because there are translators from
Type 1 to TrueType (the reverse can never work as well, since TrueType
can't capture the same information). When generating a font, you want to
use tools that preserve as much of the thinking and logical structure that
went into the design as possible. Type 1 does this, and you can
still get usable TrueType if you run into cases where the Type 1
rasterizer isn't adequate. I think the development of TrueType was
motivated more by the need for a low-end technology that cost less and
could be implemented on modest hardware, than as a replacement for
Type1 fonts in "high-end" publishing.
--
George N. White III <gn...@acm.org> Bedford Institute of Oceanography
RSD99
I think the development of TrueType was
motivated more by the need for a low-end technology that cost less and
could be implemented on modest hardware, than as a replacement for
Type1 fonts in "high-end" publishing.
..."
True. IIRC One of the stated objectives ... if not the dominant one ... was so that Apple
(and later Microsoft) would no longer have to pay royalties to Adobe for the use of
PostScript.
"George N. White III" <Whi...@dfo-mpo.gc.ca> wrote in message
news:Pine.GSO.4.44.02082...@emerald.bio.dfo.ca...
Richard J Kinch
> How in the world
> did we end up in such a mess when it comes to hinting?
The ugliness is due in my estimation mostly to competing commercial
interests (natural monopolies of single open computing standards versus
profit potential of fragmented proprietary standards). Type 1 hinting is
ad hoc, primitive, effective, and appropriate for the mid-80s technology it
was designed for. TrueType hinting was partly an admirable attempt to
generalize hinting and thus improve it over Type 1, but in practice it is
so clumsy as to make it generally unusable.
TrueType internals also have a heavy Macintosh flavor, which seems to
inhibit any joy for those like me who find that distasteful. TrueType
authoring tools seem all to be visual tools for artistic minds rather than
programming tools for analytic minds. If you want to craft one font as
your neurotic life's work, via the agony of endless twiddling of every
glyph by hand, then that's OK, but if you have hundreds of fonts to
manipulate that is not the right approach.
There was an effort called Display PostScript that could have been the
marking model (what the Windows GDI is) for Windows, and this would have
used Type 1 instead of TrueType for fonts. ATM is a kind of retrofit and
compromise partly toward that end.
Type 1 vs TrueType hinting is like folk guitar versus classical violin.
The former is relatively easy to play, rewards modest skills, yet has
limited creative range. The latter is hard to play, sounds good only with
a rather rare expert effort, yet has infinite creative possibilities.
Character
>> ... TrueType authoring tools seem all to be visual tools for artistic minds rather than programming tools for analytic minds. If you want to craft one font as your neurotic life's work, via the agony of endless twiddling of every glyph by hand, then that's OK, but if you have hundreds of fonts to manipulate that is not the right approach.
I certainly hope that I'm misunderstanding you! You seem to be saying that the
creation of a useable, consistent, readable, ęsthetic typeface should be the
result of mathematical analysis rather than visually creative artistic efforts.
The most mathematically precise graphics are subject to the most extreme
distortions when viewed by the human eye - thus we have books filled with
optical illusions where gray spots seem to appear in the middle of pristine
whiteness, lines of equal length appear radically different, and left-aligned
vertical stem "M"s appear to be far to the left of precisely equally aligned
"O"s.
No, products intended to be viewed by people's eyes are best created by people
using their eyes as tools. (OCR and MICR fonts are a whole other story, of
course!)
- Character
Ian Kemmish
>
>This sounds like a short term win because you can spend lots of
>effort building a few core fonts to render well, but requires a
>lot more effort in the long run, because you have to repeat the
>work for every font.
I think you've just answered your own question:-). That's what font editors
are for. You can download a free evalaution demo of Fontlab, I think, which
should make the design process clearer for you. Whichever format you go out
to, you deal in high level constraints and the font editor decides what to do
about it for you.....
The biggest issue these days, I think, is availability of an appropriate
rasteriser on the platform of your choice.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Ian Kemmish 18 Durham Close, Biggleswade, Beds SG18 8HZ, UK
usenet...@eeyore.demon.co.uk Tel: +44 1767 601 361
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
``Behind every successful organisation stands one person who knows the secret
of how to keep the managers away from anything truly important.''
Richard J Kinch
> I certainly hope that I'm misunderstanding you! You seem to be saying
> that the creation of a useable, consistent, readable, ęsthetic
> typeface should be the result of mathematical analysis rather than
> visually creative artistic efforts.
You are misunderstanding me. We're talking about hinting, not designs
themselves. If you want to apply a given hint to a dozen characters, with
the current visual tools you have to do the same tedious mouse-clicking a
dozen times. There should be a way to specify the hint once, and have it
repeat, programmatically, that is, using a language instead of a mouse.
My philosophy is that no tool is operationally complete until whatever it
can do can be be specified in a language, not just with mouse clicks.
Anything less is a deficiency.
Character
- Character
John Doherty
<nob...@nowhere.com> wrote:
> You are misunderstanding me. We're talking about hinting, not designs
> themselves. If you want to apply a given hint to a dozen characters, with
> the current visual tools you have to do the same tedious mouse-clicking a
> dozen times. There should be a way to specify the hint once, and have it
> repeat, programmatically, that is, using a language instead of a mouse.
Ever looked into RoboFog? I haven't used it, but basically, it's a
Python scripting interface to control Fontographer.
> My philosophy is that no tool is operationally complete until whatever it
> can do can be be specified in a language, not just with mouse clicks.
> Anything less is a deficiency.
I think the RoboFog guys felt much the same way. :-)
--
Marek Williams
<con...@mds.rmit.edu.au> dijo:
>Does this reflect the real situation? How good are the Type 1
>hinting engines? If I were to design a new font, should I go
>for Type 1 or TrueType?
Neither. The future is OpenType.
--
Bogus e-mail address, but I read this newsgroup regularly, so reply here.
Richard J Kinch
> Ever looked into RoboFog? I haven't used it, but basically, it's a
> Python scripting interface to control Fontographer.
Scripting interfaces are OK, but not what I mean. There should be a
language interface to all the facilities of a software tool, without having
to approach the GUI. In this case, a way to say add hint type X to
position Y of characters Z1, Z2, ..., etc.
RSD99
If I were to design a new font, should I go for Type 1 or TrueType?
and
"...
Neither. The future is OpenType.
Well ... it appears that
(A) Microsoft and cohorts are building "OpenType Fonts" based on TrueType internals, and
(B) Adobe is building "OpenType Fonts" based on PostScript internals.
So (IMHO) the question is a valid one.
Maybe we should go back to the basics (where many people say PostScript is the preferred
format) ... see the discussions regarding TrueType Vs PostScript at
http://cgm.cs.mcgill.ca/~luc/ttvst1.html
http://www.hardcovermedia.com/lab/Pages/Misc/ttvst1.htm
http://www.font.to/downloads/TT_PS_OT.pdf
http://www.truetype.demon.co.uk/articles/ttvst1.htm
http://www.truetype.demon.co.uk/ttandt1.htm
"Marek Williams" <a...@example.com> wrote in message
news:mc3emuoppg4pukqi0...@4ax.com...
Marek Williams
dijo:
>(A) Microsoft and cohorts are building "OpenType Fonts" based on TrueType internals, and
>(B) Adobe is building "OpenType Fonts" based on PostScript internals.
Indeed, that is correct. But there are advantages to OpenType even if
a vendor merely converts a TT or T1 font, chief of which is platform
indpendence. It is really cool to send my fonts to a service bureau
and never have to worry about whether they are Mac or Win.
And what you say is correct, except Adobe is also producing the Pro
fonts. Presumably, all their OpenType offerings will be Pro versions
eventually. These are built from the ground up as OpenType and have no
relationship to either Type 1 or TrueType, except that they will
probably recycle some of the glyphs.
Apostrophe (')
>
> And what you say is correct, except Adobe is also producing the Pro
> fonts. Presumably, all their OpenType offerings will be Pro versions
> eventually. These are built from the ground up as OpenType and have no
> relationship to either Type 1 or TrueType, except that they will
> probably recycle some of the glyphs.
There is no such thing as 'built from the ground up' OpenType font. This
sounds a lot like what Adobe would say at a convention :o)
An OpenType font is either Type 1 or True Type, with a wrapper around it and
some code attached to it. The majority of Adobe's Pro fonts contain the
outlines, point for point, from their Type 1 predecessors. Granted, new
glyphs and some code were added to give them OT functionality, but there is
nothing 'from the ground up' about them. A glyph's outline has to be either
cubic or quadratic. OpenType is not a technology with its own
outline-defining algorithm. It's just a wrapper and a code-pocket.
'Recycling some of the glyphs' is the name of the game.
Also, I wouldn't presume that all of Adobe's OT offerings will be Pro
versions eventually. I just can't see how the effort spent on turning, say,
a Hobo or an Aachen, into Pro versions would be justified. Such stuff will
never really have a market. The Pro versions consist of Adobe's best-selling
and most used faces -- that's Adobe's own faces, not ITC's or Monotype's;
there would just be too much risk in turning Plantin or ITC Bodoni into OT.
The first slap hurts enough to last forever. Look what happened to their
Berthold stuff. Two years ago, in the rush of converting their whole library
to OT (what is now known as the Standard fonts) Adobe spent time and effort
on doing the Bertholds as part of the endeavour, only to be faced with a
lawsuit and lose the fonts anyhow. This could happen with Agfa or Linotype
at any given turn of the tale. I too would love to see a Galliard Pro and an
Ocean Sans Pro, but I'm not holding my breath about seeing them any time
soon.
Tim Murray
hinting, but that it's such a pain in the rear to deal with that many
developers hint only to what you might call the "coarse" level, and not
drill down into the subtle details. Thus, the hinting you end up with in the
T1 is better than many TT.
RSD99
"Tim Murray" <tlmu...@techknowledge-no-spam-corp.com> wrote in message
news:zM6c9.10530$vY2.1...@e3500-atl2.usenetserver.com...
Dr Thomas Conway
Right. My background is partly in software engineering, and it
stikes me that an elegant simple mechanism that is higher level
and easier to get right, is likely to lead as you suggest, to
a generally better quality result. (You can write good software in
assembler, but it's easier to generally produce good software in
Java, even though the memory footprint/cpu usage of the former
might be better than the latter.)
Tim Murray
> easier to generally produce good software in Java,
> even though the memory footprint/cpu usage of the
> former might be better than the latter.)
Any old-timers here might recall PublishIt!, a Macintosh DTP program that
was a superb product with PageMaker-like quality and database publishing
tools.
It was written in Assembler, and the program fit on a single-sided diskette.
The dictionary and samples took up their own diskette. It ran just fine on a
meg or so of RAM.
Marek Williams
<tlmu...@techknowledge-no-spam-corp.com> dijo:
>Any old-timers here might recall PublishIt!, a Macintosh DTP program that
>was a superb product with PageMaker-like quality and database publishing
>tools.
I always thought that program died because of its unfortunate name.