Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
637 lines (564 sloc) 24.2 KB
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
# -----------------------------------------------------------------------------
##############################################################################
# Load font into texture
from __future__ import division
import numpy as np
from copy import deepcopy
import sys
from ._sdf_gpu import SDFRendererGPU
from ._sdf_cpu import _calc_distance_field
from ...gloo import (TextureAtlas, IndexBuffer, VertexBuffer)
from ...gloo import context
from ...gloo.wrappers import _check_valid
from ...ext.six import string_types
from ...util.fonts import _load_glyph
from ..transforms import STTransform
from ...color import ColorArray
from ..visual import Visual
from ...io import load_spatial_filters
class TextureFont(object):
"""Gather a set of glyphs relative to a given font name and size
This currently stores characters in a `TextureAtlas` object which uses
a 2D RGB texture to store unsigned 8-bit integer data. In the future this
could be changed to a ``GL_R8`` texture instead of RGB when OpenGL ES
3.0+ is standard. Since VisPy tries to stay compatible with OpenGL ES 2.0
we are using an ``RGB`` texture. Using a single channel texture should
improve performance by requiring less data to be sent to the GPU and to
remote backends (jupyter notebook).
Parameters
----------
font : dict
Dict with entries "face", "size", "bold", "italic".
renderer : instance of SDFRenderer
SDF renderer to use.
"""
def __init__(self, font, renderer):
self._atlas = TextureAtlas(dtype=np.uint8)
self._atlas.wrapping = 'clamp_to_edge'
self._kernel, _ = load_spatial_filters()
self._renderer = renderer
self._font = deepcopy(font)
self._font['size'] = 256 # use high resolution point size for SDF
self._lowres_size = 64 # end at this point size for storage
assert (self._font['size'] % self._lowres_size) == 0
# spread/border at the high-res for SDF calculation; must be chosen
# relative to fragment_insert.glsl multiplication factor to ensure we
# get to zero at the edges of characters
# This is also used in SDFRendererCPU, so changing this needs to
# propagate at least 2 other places.
self._spread = 32
assert self._spread % self.ratio == 0
self._glyphs = {}
@property
def ratio(self):
"""Ratio of the initial high-res to final stored low-res glyph"""
return self._font['size'] // self._lowres_size
@property
def slop(self):
"""Extra space along each glyph edge due to SDF borders"""
return self._spread // self.ratio
def __getitem__(self, char):
if not (isinstance(char, string_types) and len(char) == 1):
raise TypeError('index must be a 1-character string')
if char not in self._glyphs:
self._load_char(char)
return self._glyphs[char]
def _load_char(self, char):
"""Build and store a glyph corresponding to an individual character
Parameters
----------
char : str
A single character to be represented.
"""
assert isinstance(char, string_types) and len(char) == 1
assert char not in self._glyphs
# load new glyph data from font
_load_glyph(self._font, char, self._glyphs)
# put new glyph into the texture
glyph = self._glyphs[char]
bitmap = glyph['bitmap']
# convert to padded array
data = np.zeros((bitmap.shape[0] + 2*self._spread,
bitmap.shape[1] + 2*self._spread), np.uint8)
data[self._spread:-self._spread, self._spread:-self._spread] = bitmap
# Store, while scaling down to proper size
height = data.shape[0] // self.ratio
width = data.shape[1] // self.ratio
region = self._atlas.get_free_region(width + 2, height + 2)
if region is None:
raise RuntimeError('Cannot store glyph')
x, y, w, h = region
x, y, w, h = x + 1, y + 1, w - 2, h - 2
self._renderer.render_to_texture(data, self._atlas, (x, y), (w, h))
u0 = x / float(self._atlas.shape[1])
v0 = y / float(self._atlas.shape[0])
u1 = (x+w) / float(self._atlas.shape[1])
v1 = (y+h) / float(self._atlas.shape[0])
texcoords = (u0, v0, u1, v1)
glyph.update(dict(size=(w, h), texcoords=texcoords))
class FontManager(object):
"""Helper to create TextureFont instances and reuse them when possible"""
# XXX: should store a font-manager on each context,
# or let TextureFont use a TextureAtlas for each context
def __init__(self, method='cpu'):
self._fonts = {}
if not isinstance(method, string_types) or \
method not in ('cpu', 'gpu'):
raise ValueError('method must be "cpu" or "gpu", got %s (%s)'
% (method, type(method)))
if method == 'cpu':
self._renderer = SDFRendererCPU()
else: # method == 'gpu':
self._renderer = SDFRendererGPU()
def get_font(self, face, bold=False, italic=False):
"""Get a font described by face and size"""
key = '%s-%s-%s' % (face, bold, italic)
if key not in self._fonts:
font = dict(face=face, bold=bold, italic=italic)
self._fonts[key] = TextureFont(font, self._renderer)
return self._fonts[key]
##############################################################################
# The visual
def _text_to_vbo(text, font, anchor_x, anchor_y, lowres_size):
"""Convert text characters to VBO"""
# Necessary to flush commands before requesting current viewport because
# There may be a set_viewport command waiting in the queue.
# TODO: would be nicer if each canvas just remembers and manages its own
# viewport, rather than relying on the context for this.
canvas = context.get_current_canvas()
canvas.context.flush_commands()
text_vtype = np.dtype([('a_position', np.float32, 2),
('a_texcoord', np.float32, 2)])
vertices = np.zeros(len(text) * 4, dtype=text_vtype)
prev = None
width = height = ascender = descender = 0
ratio, slop = 1. / font.ratio, font.slop
x_off = -slop
# Need to make sure we have a unicode string here (Py2.7 mis-interprets
# characters like "•" otherwise)
if sys.version[0] == '2' and isinstance(text, str):
text = text.decode('utf-8')
# Need to store the original viewport, because the font[char] will
# trigger SDF rendering, which changes our viewport
# todo: get rid of call to glGetParameter!
# Also analyse chars with large ascender and descender, otherwise the
# vertical alignment can be very inconsistent
for char in 'hy':
glyph = font[char]
y0 = glyph['offset'][1] * ratio + slop
y1 = y0 - glyph['size'][1]
ascender = max(ascender, y0 - slop)
descender = min(descender, y1 + slop)
height = max(height, glyph['size'][1] - 2*slop)
# Get/set the fonts whitespace length and line height (size of this ok?)
glyph = font[' ']
spacewidth = glyph['advance'] * ratio
lineheight = height * 1.5
# Added escape sequences characters: {unicode:offset,...}
# ord('\a') = 7
# ord('\b') = 8
# ord('\f') = 12
# ord('\n') = 10 => linebreak
# ord('\r') = 13
# ord('\t') = 9 => tab, set equal 4 whitespaces?
# ord('\v') = 11 => vertical tab, set equal 4 linebreaks?
# If text coordinate offset > 0 -> it applies to x-direction
# If text coordinate offset < 0 -> it applies to y-direction
esc_seq = {7: 0, 8: 0, 9: -4, 10: 1, 11: 4, 12: 0, 13: 0}
# Keep track of y_offset to set lines at right position
y_offset = 0
# When a line break occur, record the vertices index value
vi_marker = 0
ii_offset = 0 # Offset since certain characters won't be drawn
# The running tracker of characters vertex index
vi = 0
orig_viewport = canvas.context.get_viewport()
for ii, char in enumerate(text):
if ord(char) in esc_seq:
if esc_seq[ord(char)] < 0:
# Add offset in x-direction
x_off += abs(esc_seq[ord(char)]) * spacewidth
width += abs(esc_seq[ord(char)]) * spacewidth
elif esc_seq[ord(char)] > 0:
# Add offset in y-direction and reset things in x-direction
dx = dy = 0
if anchor_x == 'right':
dx = -width
elif anchor_x == 'center':
dx = -width / 2.
vertices['a_position'][vi_marker:vi+4] += (dx, dy)
vi_marker = vi+4
ii_offset -= 1
# Reset variables that affects x-direction positioning
x_off = -slop
width = 0
# Add offset in y-direction
y_offset += esc_seq[ord(char)] * lineheight
else:
# For ordinary characters, normal procedure
glyph = font[char]
kerning = glyph['kerning'].get(prev, 0.) * ratio
x0 = x_off + glyph['offset'][0] * ratio + kerning
y0 = glyph['offset'][1] * ratio + slop - y_offset
x1 = x0 + glyph['size'][0]
y1 = y0 - glyph['size'][1]
u0, v0, u1, v1 = glyph['texcoords']
position = [[x0, y0], [x0, y1], [x1, y1], [x1, y0]]
texcoords = [[u0, v0], [u0, v1], [u1, v1], [u1, v0]]
vi = (ii + ii_offset) * 4
vertices['a_position'][vi:vi+4] = position
vertices['a_texcoord'][vi:vi+4] = texcoords
x_move = glyph['advance'] * ratio + kerning
x_off += x_move
ascender = max(ascender, y0 - slop)
descender = min(descender, y1 + slop)
width += x_move
height = max(height, glyph['size'][1] - 2*slop)
prev = char
if orig_viewport is not None:
canvas.context.set_viewport(*orig_viewport)
dx = dy = 0
if anchor_y == 'top':
dy = -descender
elif anchor_y in ('center', 'middle'):
dy = (-descender - ascender) / 2
elif anchor_y == 'bottom':
dy = -ascender
if anchor_x == 'right':
dx = -width
elif anchor_x == 'center':
dx = -width / 2.
# If any linebreaks occured in text, we only want to translate characters
# in the last line in text (those after the vi_marker)
vertices['a_position'][0:vi_marker] += (0, dy)
vertices['a_position'][vi_marker:] += (dx, dy)
vertices['a_position'] /= lowres_size
return vertices
class TextVisual(Visual):
"""Visual that displays text
Note: SDF GPU is not currently supported in WebGL without additional
extensions (see comments in fragment shader below).
Parameters
----------
text : str | list of str
Text to display. Can also be a list of strings.
Note: support for list of str might be removed soon
in favor of text collections.
color : instance of Color
Color to use.
bold : bool
Bold face.
italic : bool
Italic face.
face : str
Font face to use.
font_size : float
Point size to use.
pos : tuple | list of tuple
Position (x, y) or (x, y, z) of the text.
Can also be a list of tuple if `text` is a list.
rotation : float
Rotation (in degrees) of the text clockwise.
anchor_x : str
Horizontal text anchor.
anchor_y : str
Vertical text anchor.
method : str
Rendering method for text characters. Either 'cpu' (default) or
'gpu'. The 'cpu' method should perform better on remote backends
like those based on WebGL. The 'gpu' method should produce higher
quality results.
font_manager : object | None
Font manager to use (can be shared if the GLContext is shared).
"""
VERTEX_SHADER = """
attribute float a_rotation; // rotation in rad
attribute vec2 a_position; // in point units
attribute vec2 a_texcoord;
attribute vec3 a_pos; // anchor position
varying vec2 v_texcoord;
varying vec4 v_color;
void main(void) {
// Eventually "rot" should be handled by SRTTransform or so...
mat4 rot = mat4(cos(a_rotation), -sin(a_rotation), 0, 0,
sin(a_rotation), cos(a_rotation), 0, 0,
0, 0, 1, 0, 0, 0, 0, 1);
vec4 pos = $transform(vec4(a_pos, 1.0)) +
$text_scale(rot * vec4(a_position, 0, 0));
gl_Position = pos;
v_texcoord = a_texcoord;
v_color = $color;
}
"""
FRAGMENT_SHADER = """
// Extensions for WebGL
#extension GL_OES_standard_derivatives : enable
#extension GL_OES_element_index_uint : enable
#include "misc/spatial-filters.frag"
// Adapted from glumpy with permission
const float M_SQRT1_2 = 0.707106781186547524400844362104849039;
uniform sampler2D u_font_atlas;
uniform vec2 u_font_atlas_shape;
varying vec4 v_color;
uniform float u_npix;
varying vec2 v_texcoord;
const float center = 0.5;
float contour(in float d, in float w)
{
return smoothstep(center - w, center + w, d);
}
float sample(sampler2D texture, vec2 uv, float w)
{
return contour(texture2D(texture, uv).r, w);
}
void main(void) {
vec2 uv = v_texcoord.xy;
vec4 rgb;
// Use interpolation at high font sizes
if(u_npix >= 50.0)
rgb = CatRom(u_font_atlas, u_font_atlas_shape, uv);
else
rgb = texture2D(u_font_atlas, uv);
float distance = rgb.r;
// GLSL's fwidth = abs(dFdx(uv)) + abs(dFdy(uv))
float width = 0.5 * fwidth(distance); // sharpens a bit
// Regular SDF
float alpha = contour(distance, width);
if (u_npix < 30.) {
// Supersample, 4 extra points
// Half of 1/sqrt2; you can play with this
float dscale = 0.5 * M_SQRT1_2;
vec2 duv = dscale * (dFdx(v_texcoord) + dFdy(v_texcoord));
vec4 box = vec4(v_texcoord-duv, v_texcoord+duv);
float asum = sample(u_font_atlas, box.xy, width)
+ sample(u_font_atlas, box.zw, width)
+ sample(u_font_atlas, box.xw, width)
+ sample(u_font_atlas, box.zy, width);
// weighted average, with 4 extra points having 0.5 weight
// each, so 1 + 0.5*4 = 3 is the divisor
alpha = (alpha + 0.5 * asum) / 3.0;
}
gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);
}
"""
def __init__(self, text=None, color='black', bold=False,
italic=False, face='OpenSans', font_size=12, pos=[0, 0, 0],
rotation=0., anchor_x='center', anchor_y='center',
method='cpu', font_manager=None):
Visual.__init__(self, vcode=self.VERTEX_SHADER,
fcode=self.FRAGMENT_SHADER)
# Check input
valid_keys = ('top', 'center', 'middle', 'baseline', 'bottom')
_check_valid('anchor_y', anchor_y, valid_keys)
valid_keys = ('left', 'center', 'right')
_check_valid('anchor_x', anchor_x, valid_keys)
# Init font handling stuff
# _font_manager is a temporary solution to use global mananger
self._font_manager = font_manager or FontManager(method=method)
self._font = self._font_manager.get_font(face, bold, italic)
self._vertices = None
self._color_vbo = None
self._anchors = (anchor_x, anchor_y)
# Init text properties
self.color = color
self.text = text
self.font_size = font_size
self.pos = pos
self.rotation = rotation
self._text_scale = STTransform()
self._draw_mode = 'triangles'
self.set_gl_state(blend=True, depth_test=False, cull_face=False,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.freeze()
@property
def text(self):
"""The text string"""
return self._text
@text.setter
def text(self, text):
if isinstance(text, list):
assert all(isinstance(t, string_types) for t in text)
if text is None:
text = []
self._text = text
self._vertices = None
self._pos_changed = True # need to update this as well
self._color_changed = True
self.update()
@property
def anchors(self):
return self._anchors
@anchors.setter
def anchors(self, a):
self._anchors = a
self._vertices = None
self._pos_changed = True
self.update()
@property
def font_size(self):
""" The font size (in points) of the text
"""
return self._font_size
@font_size.setter
def font_size(self, size):
self._font_size = max(0.0, float(size))
self.update()
@property
def color(self):
""" The color of the text
"""
return self._color
@color.setter
def color(self, color):
self._color = ColorArray(color)
self._color_changed = True
self.update()
@property
def rotation(self):
""" The rotation of the text (clockwise, in degrees)
"""
return self._rotation * 180. / np.pi
@rotation.setter
def rotation(self, rotation):
self._rotation = np.asarray(rotation) * np.pi / 180.
self._pos_changed = True
self.update()
@property
def pos(self):
""" The position of the text anchor in the local coordinate frame
"""
return self._pos
@pos.setter
def pos(self, pos):
pos = np.atleast_2d(pos).astype(np.float32)
if pos.shape[1] == 2:
pos = np.concatenate((pos, np.zeros((pos.shape[0], 1),
np.float32)), axis=1)
elif pos.shape[1] != 3:
raise ValueError('pos must have 2 or 3 elements')
elif pos.shape[0] == 0:
raise ValueError('at least one position must be given')
self._pos = pos
self._pos_changed = True
self.update()
def _prepare_draw(self, view):
# attributes / uniforms are not available until program is built
if len(self.text) == 0:
return False
if self._vertices is None:
text = self.text
if isinstance(text, string_types):
text = [text]
n_char = sum(len(t) for t in text)
# we delay creating vertices because it requires a context,
# which may or may not exist when the object is initialized
self._vertices = np.concatenate([
_text_to_vbo(t, self._font, self._anchors[0], self._anchors[1],
self._font._lowres_size) for t in text])
self._vertices = VertexBuffer(self._vertices)
idx = (np.array([0, 1, 2, 0, 2, 3], np.uint32) +
np.arange(0, 4*n_char, 4, dtype=np.uint32)[:, np.newaxis])
self._index_buffer = IndexBuffer(idx.ravel())
self.shared_program.bind(self._vertices)
# This is necessary to reset the GL drawing state after generating
# SDF textures. A better way would be to enable the state to be
# pushed/popped by the context.
self._configure_gl_state()
if self._pos_changed:
# now we promote pos to the proper shape (attribute)
text = self.text
if not isinstance(text, string_types):
repeats = [4 * len(t) for t in text]
text = ''.join(text)
else:
repeats = [4 * len(text)]
n_text = len(repeats)
pos = self.pos
# Rotation
_rot = self._rotation
if isinstance(_rot, (int, float)):
_rot = np.full((pos.shape[0],), self._rotation)
_rot = np.asarray(_rot)
if _rot.shape[0] < n_text:
_rep = [1] * (len(_rot) - 1) + [n_text - len(_rot) + 1]
_rot = np.repeat(_rot, _rep, axis=0)
_rot = np.repeat(_rot[:n_text], repeats, axis=0)
self.shared_program['a_rotation'] = _rot.astype(np.float32)
# Position
if pos.shape[0] < n_text:
_rep = [1] * (len(pos) - 1) + [n_text - len(pos) + 1]
pos = np.repeat(pos, _rep, axis=0)
pos = np.repeat(pos[:n_text], repeats, axis=0)
assert pos.shape[0] == self._vertices.size == len(_rot)
self.shared_program['a_pos'] = pos
self._pos_changed = False
if self._color_changed:
# now we promote color to the proper shape (varying)
text = self.text
if not isinstance(text, string_types):
repeats = [4 * len(t) for t in text]
text = ''.join(text)
else:
repeats = [4 * len(text)]
n_text = len(repeats)
color = self.color.rgba
if color.shape[0] < n_text:
color = np.repeat(color,
[1]*(len(color)-1) + [n_text-len(color)+1],
axis=0)
color = np.repeat(color[:n_text], repeats, axis=0)
assert color.shape[0] == self._vertices.size
self._color_vbo = VertexBuffer(color)
self.shared_program.vert['color'] = self._color_vbo
self._color_changed = False
transforms = self.transforms
n_pix = (self._font_size / 72.) * transforms.dpi # logical pix
tr = transforms.get_transform('document', 'render')
px_scale = (tr.map((1, 0)) - tr.map((0, 1)))[:2]
self._text_scale.scale = px_scale * n_pix
self.shared_program.vert['text_scale'] = self._text_scale
self.shared_program['u_npix'] = n_pix
self.shared_program['u_kernel'] = self._font._kernel
self.shared_program['u_color'] = self._color.rgba
self.shared_program['u_font_atlas'] = self._font._atlas
self.shared_program['u_font_atlas_shape'] = self._font._atlas.shape[:2]
def _prepare_transforms(self, view):
self._pos_changed = True
# Note that we access `view_program` instead of `shared_program`
# because we do not want this function assigned to other views.
tr = view.transforms.get_transform()
view.view_program.vert['transform'] = tr # .simplified()
def _compute_bounds(self, axis, view):
return self._pos[:, axis].min(), self._pos[:, axis].max()
class SDFRendererCPU(object):
"""Render SDFs using the CPU."""
# This should probably live in _sdf_cpu.pyx, but doing so makes
# debugging substantially more annoying
def render_to_texture(self, data, texture, offset, size):
sdf = (data / 255).astype(np.float32) # from ubyte -> float
h, w = sdf.shape
tex_w, tex_h = size
_calc_distance_field(sdf, w, h, 32)
# This tweaking gets us a result more similar to the GPU SDFs,
# for which the text rendering code was optimized
sdf = 2 * sdf - 1.
sdf = np.sign(sdf) * np.abs(sdf) ** 0.75 / 2. + 0.5
# Downsample using NumPy (because we can't guarantee SciPy)
xp = (np.arange(w) + 0.5) / float(w)
x = (np.arange(tex_w) + 0.5) / float(tex_w)
bitmap = np.array([np.interp(x, xp, ss) for ss in sdf])
xp = (np.arange(h) + 0.5) / float(h)
x = (np.arange(tex_h) + 0.5) / float(tex_h)
bitmap = np.array([np.interp(x, xp, ss) for ss in bitmap.T]).T
assert bitmap.shape[::-1] == size
# convert to uint8
bitmap = (bitmap * 255).astype(np.uint8)
# convert single channel to RGB by repeating
bitmap = np.tile(bitmap[..., np.newaxis],
(1, 1, 3))
texture[offset[1]:offset[1] + size[1],
offset[0]:offset[0] + size[0], :] = bitmap
You can’t perform that action at this time.