338 lines
14 KiB
Python
338 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
||
|
||
"""Pen to rasterize paths with FreeType."""
|
||
|
||
__all__ = ['FTPen']
|
||
|
||
import os
|
||
import ctypes
|
||
import platform
|
||
import subprocess
|
||
import collections
|
||
import math
|
||
|
||
import freetype
|
||
from freetype.raw import FT_Outline_Get_Bitmap, FT_Outline_Get_BBox, FT_Outline_Get_CBox
|
||
from freetype.ft_types import FT_Pos
|
||
from freetype.ft_structs import FT_Vector, FT_BBox, FT_Bitmap, FT_Outline
|
||
from freetype.ft_enums import FT_OUTLINE_NONE, FT_OUTLINE_EVEN_ODD_FILL, FT_PIXEL_MODE_GRAY
|
||
from freetype.ft_errors import FT_Exception
|
||
|
||
from fontTools.pens.basePen import BasePen
|
||
from fontTools.misc.roundTools import otRound
|
||
|
||
Contour = collections.namedtuple('Contour', ('points', 'tags'))
|
||
LINE = 0b00000001
|
||
CURVE = 0b00000011
|
||
OFFCURVE = 0b00000010
|
||
QCURVE = 0b00000001
|
||
QOFFCURVE = 0b00000000
|
||
|
||
class FTPen(BasePen):
|
||
"""Pen to rasterize paths with FreeType. Requires `freetype-py` module.
|
||
|
||
Constructs ``FT_Outline`` from the paths, and renders it within a bitmap
|
||
buffer.
|
||
|
||
For ``array()`` and ``show()``, `numpy` and `matplotlib` must be installed.
|
||
For ``image()``, `Pillow` is required. Each module is lazily loaded when the
|
||
corresponding method is called.
|
||
|
||
Args:
|
||
glyphSet: a dictionary of drawable glyph objects keyed by name
|
||
used to resolve component references in composite glyphs.
|
||
|
||
:Examples:
|
||
If `numpy` and `matplotlib` is available, the following code will
|
||
show the glyph image of `fi` in a new window::
|
||
|
||
from fontTools.ttLib import TTFont
|
||
from fontTools.pens.ftPen import FTPen
|
||
pen = FTPen(None)
|
||
font = TTFont('SourceSansPro-Regular.otf')
|
||
glyph = font.getGlyphSet()['fi']
|
||
glyph.draw(pen)
|
||
width, ascender, descender = glyph.width, font['OS/2'].usWinAscent, -font['OS/2'].usWinDescent
|
||
height = ascender - descender
|
||
pen.show(offset=(0, -descender), width=width, height=height)
|
||
|
||
Combining with `uharfbuzz`, you can typeset a chunk of glyphs in a pen::
|
||
|
||
import uharfbuzz as hb
|
||
from fontTools.pens.ftPen import FTPen
|
||
from fontTools.pens.transformPen import TransformPen
|
||
from fontTools.misc.transform import Offset
|
||
|
||
en1, en2, ar, ja = 'Typesetting', 'Jeff', 'صف الحروف', 'たいぷせっと'
|
||
for text, font_path, direction, typo_ascender, typo_descender, vhea_ascender, vhea_descender, contain, features in (
|
||
(en1, 'NotoSans-Regular.ttf', 'ltr', 2189, -600, None, None, False, {"kern": True, "liga": True}),
|
||
(en2, 'NotoSans-Regular.ttf', 'ltr', 2189, -600, None, None, True, {"kern": True, "liga": True}),
|
||
(ar, 'NotoSansArabic-Regular.ttf', 'rtl', 1374, -738, None, None, False, {"kern": True, "liga": True}),
|
||
(ja, 'NotoSansJP-Regular.otf', 'ltr', 880, -120, 500, -500, False, {"palt": True, "kern": True}),
|
||
(ja, 'NotoSansJP-Regular.otf', 'ttb', 880, -120, 500, -500, False, {"vert": True, "vpal": True, "vkrn": True})
|
||
):
|
||
blob = hb.Blob.from_file_path(font_path)
|
||
face = hb.Face(blob)
|
||
font = hb.Font(face)
|
||
buf = hb.Buffer()
|
||
buf.direction = direction
|
||
buf.add_str(text)
|
||
buf.guess_segment_properties()
|
||
hb.shape(font, buf, features)
|
||
|
||
x, y = 0, 0
|
||
pen = FTPen(None)
|
||
for info, pos in zip(buf.glyph_infos, buf.glyph_positions):
|
||
gid = info.codepoint
|
||
transformed = TransformPen(pen, Offset(x + pos.x_offset, y + pos.y_offset))
|
||
font.draw_glyph_with_pen(gid, transformed)
|
||
x += pos.x_advance
|
||
y += pos.y_advance
|
||
|
||
offset, width, height = None, None, None
|
||
if direction in ('ltr', 'rtl'):
|
||
offset = (0, -typo_descender)
|
||
width = x
|
||
height = typo_ascender - typo_descender
|
||
else:
|
||
offset = (-vhea_descender, -y)
|
||
width = vhea_ascender - vhea_descender
|
||
height = -y
|
||
pen.show(offset=offset, width=width, height=height, contain=contain)
|
||
|
||
For Jupyter Notebook, the rendered image will be displayed in a cell if
|
||
you replace ``show()`` with ``image()`` in the examples.
|
||
"""
|
||
|
||
def __init__(self, glyphSet):
|
||
BasePen.__init__(self, glyphSet)
|
||
self.contours = []
|
||
|
||
def outline(self, offset=None, scale=None, even_odd=False):
|
||
"""Converts the current contours to ``FT_Outline``.
|
||
|
||
Args:
|
||
offset: A optional tuple of ``(x, y)`` used for translation.
|
||
scale: A optional tuple of ``(scale_x, scale_y)`` used for scaling.
|
||
even_odd: Pass ``True`` for even-odd fill instead of non-zero.
|
||
"""
|
||
offset = offset or (0, 0)
|
||
scale = scale or (1.0, 1.0)
|
||
nContours = len(self.contours)
|
||
n_points = sum((len(contour.points) for contour in self.contours))
|
||
points = []
|
||
for contour in self.contours:
|
||
for point in contour.points:
|
||
points.append(FT_Vector(FT_Pos(otRound((point[0] + offset[0]) * scale[0] * 64)), FT_Pos(otRound((point[1] + offset[1]) * scale[1] * 64))))
|
||
tags = []
|
||
for contour in self.contours:
|
||
for tag in contour.tags:
|
||
tags.append(tag)
|
||
contours = []
|
||
contours_sum = 0
|
||
for contour in self.contours:
|
||
contours_sum += len(contour.points)
|
||
contours.append(contours_sum - 1)
|
||
flags = FT_OUTLINE_EVEN_ODD_FILL if even_odd else FT_OUTLINE_NONE
|
||
return FT_Outline(
|
||
(ctypes.c_short)(nContours),
|
||
(ctypes.c_short)(n_points),
|
||
(FT_Vector * n_points)(*points),
|
||
(ctypes.c_ubyte * n_points)(*tags),
|
||
(ctypes.c_short * nContours)(*contours),
|
||
(ctypes.c_int)(flags)
|
||
)
|
||
|
||
def buffer(self, offset=None, width=1000, height=1000, even_odd=False, scale=None, contain=False):
|
||
"""Renders the current contours within a bitmap buffer.
|
||
|
||
Args:
|
||
offset: A optional tuple of ``(x, y)`` used for translation.
|
||
Typically ``(0, -descender)`` can be passed so that the glyph
|
||
image would not been clipped.
|
||
width: Image width of the bitmap in pixels.
|
||
height: Image height of the bitmap in pixels.
|
||
scale: A optional tuple of ``(scale_x, scale_y)`` used for scaling.
|
||
even_odd: Pass ``True`` for even-odd fill instead of non-zero.
|
||
contain: If ``True``, the image size will be automatically expanded
|
||
so that it fits to the bounding box of the paths. Useful for
|
||
rendering glyphs with negative sidebearings without clipping.
|
||
|
||
Returns:
|
||
A tuple of ``(buffer, size)``, where ``buffer`` is a ``bytes``
|
||
object of the resulted bitmap and ``size` is a 2-tuple of its
|
||
dimension.
|
||
|
||
:Example:
|
||
>>> pen = FTPen(None)
|
||
>>> glyph.draw(pen)
|
||
>>> buf, size = pen.buffer(width=500, height=1000)
|
||
>>> type(buf), len(buf), size
|
||
(<class 'bytes'>, 500000, (500, 1000))
|
||
"""
|
||
offset_x, offset_y = offset or (0, 0)
|
||
if contain:
|
||
bbox = self.bbox
|
||
bbox_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
|
||
offset_x = min(offset_x, bbox[0]) * -1
|
||
width = max(width, bbox_size[0])
|
||
offset_y = min(offset_y, bbox[1]) * -1
|
||
height = max(height, bbox_size[1])
|
||
scale = scale or (1.0, 1.0)
|
||
width = math.ceil(width * scale[0])
|
||
height = math.ceil(height * scale[1])
|
||
buf = ctypes.create_string_buffer(width * height)
|
||
bitmap = FT_Bitmap(
|
||
(ctypes.c_int)(height),
|
||
(ctypes.c_int)(width),
|
||
(ctypes.c_int)(width),
|
||
(ctypes.POINTER(ctypes.c_ubyte))(buf),
|
||
(ctypes.c_short)(256),
|
||
(ctypes.c_ubyte)(FT_PIXEL_MODE_GRAY),
|
||
(ctypes.c_char)(0),
|
||
(ctypes.c_void_p)(None)
|
||
)
|
||
outline = self.outline(offset=(offset_x, offset_y), even_odd=even_odd, scale=scale)
|
||
err = FT_Outline_Get_Bitmap(freetype.get_handle(), ctypes.byref(outline), ctypes.byref(bitmap))
|
||
if err != 0:
|
||
raise FT_Exception(err)
|
||
return buf.raw, (width, height)
|
||
|
||
def array(self, offset=None, width=1000, height=1000, even_odd=False, scale=None, contain=False):
|
||
"""Returns the rendered contours as a numpy array. Requires `numpy`.
|
||
|
||
Args:
|
||
offset: A optional tuple of ``(x, y)`` used for translation.
|
||
Typically ``(0, -descender)`` can be passed so that the glyph
|
||
image would not been clipped.
|
||
width: Image width of the bitmap in pixels.
|
||
height: Image height of the bitmap in pixels.
|
||
scale: A optional tuple of ``(scale_x, scale_y)`` used for scaling.
|
||
even_odd: Pass ``True`` for even-odd fill instead of non-zero.
|
||
contain: If ``True``, the image size will be automatically expanded
|
||
so that it fits to the bounding box of the paths. Useful for
|
||
rendering glyphs with negative sidebearings without clipping.
|
||
|
||
Returns:
|
||
A ``numpy.ndarray`` object with a shape of ``(height, width)``.
|
||
Each element takes a value in the range of ``[0.0, 1.0]``.
|
||
|
||
:Example:
|
||
>>> pen = FTPen(None)
|
||
>>> glyph.draw(pen)
|
||
>>> arr = pen.array(width=500, height=1000)
|
||
>>> type(a), a.shape
|
||
(<class 'numpy.ndarray'>, (1000, 500))
|
||
"""
|
||
import numpy as np
|
||
buf, size = self.buffer(offset=offset, width=width, height=height, even_odd=even_odd, scale=scale, contain=contain)
|
||
return np.frombuffer(buf, 'B').reshape((size[1], size[0])) / 255.0
|
||
|
||
def show(self, offset=None, width=1000, height=1000, even_odd=False, scale=None, contain=False):
|
||
"""Plots the rendered contours with `pyplot`. Requires `numpy` and
|
||
`matplotlib`.
|
||
|
||
Args:
|
||
offset: A optional tuple of ``(x, y)`` used for translation.
|
||
Typically ``(0, -descender)`` can be passed so that the glyph
|
||
image would not been clipped.
|
||
width: Image width of the bitmap in pixels.
|
||
height: Image height of the bitmap in pixels.
|
||
scale: A optional tuple of ``(scale_x, scale_y)`` used for scaling.
|
||
even_odd: Pass ``True`` for even-odd fill instead of non-zero.
|
||
contain: If ``True``, the image size will be automatically expanded
|
||
so that it fits to the bounding box of the paths. Useful for
|
||
rendering glyphs with negative sidebearings without clipping.
|
||
|
||
:Example:
|
||
>>> pen = FTPen(None)
|
||
>>> glyph.draw(pen)
|
||
>>> pen.show(width=500, height=1000)
|
||
"""
|
||
from matplotlib import pyplot as plt
|
||
a = self.array(offset=offset, width=width, height=height, even_odd=even_odd, scale=scale, contain=contain)
|
||
plt.imshow(a, cmap='gray_r', vmin=0, vmax=1)
|
||
plt.show()
|
||
|
||
def image(self, offset=None, width=1000, height=1000, even_odd=False, scale=None, contain=False):
|
||
"""Returns the rendered contours as a PIL image. Requires `Pillow`.
|
||
Can be used to display a glyph image in Jupyter Notebook.
|
||
|
||
Args:
|
||
offset: A optional tuple of ``(x, y)`` used for translation.
|
||
Typically ``(0, -descender)`` can be passed so that the glyph
|
||
image would not been clipped.
|
||
width: Image width of the bitmap in pixels.
|
||
height: Image height of the bitmap in pixels.
|
||
scale: A optional tuple of ``(scale_x, scale_y)`` used for scaling.
|
||
even_odd: Pass ``True`` for even-odd fill instead of non-zero.
|
||
contain: If ``True``, the image size will be automatically expanded
|
||
so that it fits to the bounding box of the paths. Useful for
|
||
rendering glyphs with negative sidebearings without clipping.
|
||
|
||
Returns:
|
||
A ``PIL.image`` object. The image is filled in black with alpha
|
||
channel obtained from the rendered bitmap.
|
||
|
||
:Example:
|
||
>>> pen = FTPen(None)
|
||
>>> glyph.draw(pen)
|
||
>>> img = pen.image(width=500, height=1000)
|
||
>>> type(img), img.size
|
||
(<class 'PIL.Image.Image'>, (500, 1000))
|
||
"""
|
||
from PIL import Image
|
||
buf, size = self.buffer(offset=offset, width=width, height=height, even_odd=even_odd, scale=scale, contain=contain)
|
||
img = Image.new('L', size, 0)
|
||
img.putalpha(Image.frombuffer('L', size, buf))
|
||
return img
|
||
|
||
@property
|
||
def bbox(self):
|
||
"""Computes the exact bounding box of an outline.
|
||
|
||
Returns:
|
||
A tuple of ``(xMin, yMin, xMax, yMax)``.
|
||
"""
|
||
bbox = FT_BBox()
|
||
outline = self.outline()
|
||
FT_Outline_Get_BBox(ctypes.byref(outline), ctypes.byref(bbox))
|
||
return (bbox.xMin / 64.0, bbox.yMin / 64.0, bbox.xMax / 64.0, bbox.yMax / 64.0)
|
||
|
||
@property
|
||
def cbox(self):
|
||
"""Returns an outline's ‘control box’.
|
||
|
||
Returns:
|
||
A tuple of ``(xMin, yMin, xMax, yMax)``.
|
||
"""
|
||
cbox = FT_BBox()
|
||
outline = self.outline()
|
||
FT_Outline_Get_CBox(ctypes.byref(outline), ctypes.byref(cbox))
|
||
return (cbox.xMin / 64.0, cbox.yMin / 64.0, cbox.xMax / 64.0, cbox.yMax / 64.0)
|
||
|
||
def _moveTo(self, pt):
|
||
contour = Contour([], [])
|
||
self.contours.append(contour)
|
||
contour.points.append(pt)
|
||
contour.tags.append(LINE)
|
||
|
||
def _lineTo(self, pt):
|
||
contour = self.contours[-1]
|
||
contour.points.append(pt)
|
||
contour.tags.append(LINE)
|
||
|
||
def _curveToOne(self, p1, p2, p3):
|
||
t1, t2, t3 = OFFCURVE, OFFCURVE, CURVE
|
||
contour = self.contours[-1]
|
||
for p, t in ((p1, t1), (p2, t2), (p3, t3)):
|
||
contour.points.append(p)
|
||
contour.tags.append(t)
|
||
|
||
def _qCurveToOne(self, p1, p2):
|
||
t1, t2 = QOFFCURVE, QCURVE
|
||
contour = self.contours[-1]
|
||
for p, t in ((p1, t1), (p2, t2)):
|
||
contour.points.append(p)
|
||
contour.tags.append(t)
|