Permalink
Cannot retrieve contributors at this time
Join GitHub today
GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.
Sign up
Fetching contributors…
Cannot retrieve contributors at this time
| # -*- 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 |