matplotlib-devel Mailing List for matplotlib

This is a long one.
The problem with the last patch I submitted was a no brainer.
Instead of:
math_parse_s_ft2font_ps = math_parse_s_ft2font_common('PS')
should have been:
math_parse_s_ps = math_parse_s_ft2font_common('PS')
I am now in the process of creating a UnicodeFonts class, and a
derived BakomaUnicodeFonts, which is a hack to add "unicode support"
to the
Bakoma fonts. Is BakomaUnicodeFonts worth of implementing?
I must say that I had a lot of problems in reading/understanding the code
of the current Fonts classes, especially regarding the ambiguous usage
of the word "font". I also tried to make a common parent class in order to
abstract the common properties of the BakomaTrueTypeFonts and
BakomaPSFonts classes (something along the way of what I did with the
math_parse_s_ft2font_common class), but I hit the wall - there was a lot
of black magic under the hood, IMHO.
So I decided to make naming changes in the new Unicode aware classes,
and that's the purpose of writing this email before I got the new classes to
work. So please John, do comment on this, because I don't know whether
I'm breaking something, and whether the names are chosen appropriately.
The changes I made, make no effect on the current code - that is, everything
still works. I'm sending you a patch against the SVN tree. I also added
the automatically genarated tex2uni etc. files, and they are now incorporated
in the patch.
What should we do with the script that generates those file. Should I try to
integrate it into the setup/build process?
These are the new imports:
from matplotlib.tex2uni import tex2uni
from matplotlib.type12uni import type12uni
These are the new top-level functions I defined in mathtext:
def font_open(filename):
 ext = filename.rsplit('.',1)[1]
 if ext == 'afm':
 return AFM(filename)
 else:
 return FT2Font(filename)
def get_unicode_index(symbol):
 """get_unicode_index(symbol) -> integer
Return the integer index from the Unicode table of an Unicode symbol
"""
 try:# This will succeed if symbol is a single unicode char
 return ord(symbol)
 except TypeError:
 pass
 try:# Is symbol a TeX symbol (i.e. \alpha)
 return tex2uni[symbol]
 except KeyError:
 pass
 try:# Is symbol a Type1 name (i.e. degree)? If not raise error
 return type12uni[symbol]
 except KeyError:
 message = """'%(symbol)s' is not a valid Unicode character or
TeX/Type1 symbol"""%locals()
 raise ValueError, message
And finally, these are the new classes:
====
class UnicodeFonts(Fonts):
 """An abstract base class for handling Unicode fonts.
Specific terminology:
 * fontface: an FT2Font object, corresponding to a facename
 * facename: a string that defines the (type)face's name - 'rm', 'it' etc.
 * filename: a string that is used for generating a fontface object
 * symbol*: a single Unicode character or a TeX command,
 or to be precise, a TeX symbol command like \alpha (but not \frac) or
 even a Type1/PS name
 * filenamesdict: a dict that maps the face's name to the filename:
 filenamesdict = { 'cal' : 'fontnamecal.ext',
 'rm' : 'fontnamerm.ext',
 'tt' : 'fontnamett.ext',
 'it' : 'fontnameit.ext',
 None : 'fontnamesmth.ext'}
 filenamesdict should be declared as a class atribute
 * glyphdict: a dict used for caching of glyph specific data
 * fontsdict: a dict of facename -> fontface pairs
 * charmaps: a dict of facename -> charmap pairs
 * glyphmaps: a dict of facename -> glyphmap pairs. A glyphmap is an
 inverted charmap
 * output: a string in ['BMP','SVG','PS'], coresponding to the backends
 * index: Fontfile specific index of a glyph/char. Taken from a charmap.
"""
 # The path to the dir with the fontfiles
 basepath = get_data_path()
 def __init__(self, output='BMP'):
 if output:
 self.output = output
 # dict self.glyphdict[key] = facename, metrics, glyph, offset
 self.glyphdict = {}
 self.fontsdict = dict(
 [ (facename, font_open(os.path.join(self.basepath,
 filenamesdict[facename]))) for facename in
 self.facenames])
 # a dict of glyphindex -> charcode pairs
 self.charmaps = dict(
 [ (facename, self.fontsdict[facename].get_charmap())\
 for facename in self.facenames])
 # a dict of charcode -> glyphindex pairs
 self.glyphmaps = {}
 for facename in self.facenames:
 charmap = self.charmaps[facename]
 self.glyphmaps[facename] = dict([(charcode, glyphind)
 for glyphind, charcode in charmap.items()])
 for fontface in self.fontsdict.values():
 fontface.clear()
 if self.output == 'SVG':
 # a list of "glyphs" we need to render this thing in SVG
 self.svg_glyphs=[]
 def set_canvas_size(self, w, h, pswriter=None):
 'Dimension the drawing canvas; may be a noop'
 # self.width = int(w)
 # self.height = int(h)
 # I don't know why this was different than the PS version
 self.width = w
 self.height = h
 if pswriter:
 self.pswriter = pswriter
 else:
 for fontface in self.fontsdict.values():
 fontface.set_bitmap_size(int(w), int(h))
 def render(self, ox, oy, facename, symbol, fontsize, dpi):
 filename = self.filenamesdict[facename]
 metrics, glyph, offset = self._get_info(facename, symbol, fontsize,
 dpi)
 index = self._get_unicode_index(symbol)
 if self.output == 'SVG':
 oy += offset - 512/2048.*10.
 self.svg_glyphs.append((filename, fontsize, index, ox, oy,
 metrics))
 elif self.output == 'PS':
 # This should be changed to check for math mode or smth.
 #if filename == 'cmex10.ttf':
 # oy += offset - 512/2048.*10.
 psfontname = self.fontsdict[facename].postscript_name
 ps = """/%(psfontname)s findfont
%(fontsize)s scalefont
setfont
%(ox)f %(oy)f moveto
/%(glyphname)s glyphshow
""" % locals()
 self.pswriter.write(ps)
 else: # BMP
 fontface = self.fontsdict[facename]
 fontface.draw_glyph_to_bitmap(
 int(ox), int(self.height - oy - metrics.ymax), glyph)
 def get_metrics(self, facename, symbol, fontsize, dpi):
 metrics, glyph, offset = \
 self._get_info(facename, symbol, fontsize, dpi)
 return metrics
 def _get_unicode_index(self, symbol):
 return get_unicode_index(symbol)
 # Methods that must be overridden
 def _get_info(self, facename, symbol, fontsize, dpi):
 raise NotImplementedError('Derived must override')
class BakomaUnicodeFonts(UnicodeFonts):
 """A class that simulates Unicode support in the BaKoMa fonts"""
 filenamesdict = { 'cal' : 'cmsy10.ttf',
 'rm' : 'cmr10.ttf',
 'tt' : 'cmtt10.ttf',
 'it' : 'cmmi10.ttf',
 }
 def _get_info(self, facename, symbol, fontsize, dpi):
 'load the facename, metrics and glyph'
 #print hex(index), symbol, filename, facename
 key = facename, symbol, fontsize, dpi
 tup = self.glyphdict.get(key)
 if tup is not None:
 return tup
 filename = self.fontmap[facename]
 # This is black magic to me (Edin)
 if self.output == 'PS':
 if filename not in bakoma_fonts:
 bakoma_fonts.append(filename)
 fontface = self.fontsdict[facename]
 fontface.set_size(fontsize, dpi)
 head = fontface.get_sfnt_table('head')
 index = self._get_index(symbol)
 glyph = fontface.load_char(index)
 xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox]
 # This is black magic to me (Edin)
 if filename == 'cmex10.ttf':
 if self.output == 'PS':
 offset = -(head['yMin']+512)/head['unitsPerEm']*10.
 else:
 offset = glyph.height/64.0/2 + 256.0/64.0*dpi/72.0
 else:
 offset = 0.
 metrics = Bunch(
 advance = glyph.linearHoriAdvance/65536.0,
 height = glyph.height/64.0,
 width = glyph.width/64.0,
 xmin = xmin,
 xmax = xmax,
 ymin = ymin+offset,
 ymax = ymax+offset,
 )
 self.glyphdict[key] = metrics, glyph, offset
 return self.glyphdict[key]
 # We override the UnicodeFonts method
 def _get_unicode_index(self, symbol):
 pass
====
Cheers,
Edin