vispy 0.15.0__cp313-cp313-macosx_10_13_x86_64.whl

vispy/visuals/text/text.py

@@ -0,0 +1,675 @@
+# -*- 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 ...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, str) 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, str) 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, str) 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
+
+_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)) +
+                   vec4($text_scale(rot * vec4(a_position, 0.0, 1.0)).xyz, 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 = CatRom2D(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;
+        }
+
+        if (alpha <= 0) discard;
+
+        gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);
+    }
+    """
+
+
+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
+
+    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.
+        The 'gpu' method should produce higher quality results.
+    font_manager : object | None
+        Font manager to use (can be shared if the GLContext is shared).
+    depth_test : bool
+        Whether to apply depth testing. Default False. If False, the text
+        behaves like an overlay that does not get hidden behind other
+        visuals in the scene.
+    """
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': _FRAGMENT_SHADER,
+    }
+
+    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, depth_test=False):
+        Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
+        # 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._face = face
+        self._bold = bold
+        self._italic = italic
+        self._update_font()
+        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=depth_test, 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, str) 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, str):
+                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, str):
+                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, str):
+                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()
+
+    @property
+    def face(self):
+        return self._face
+
+    @face.setter
+    def face(self, value):
+        self._face = value
+        self._update_font()
+
+    @property
+    def bold(self):
+        return self._bold
+
+    @bold.setter
+    def bold(self, value):
+        self._bold = value
+        self._update_font()
+
+    @property
+    def italic(self):
+        return self._italic
+
+    @italic.setter
+    def italic(self, value):
+        self._italic = value
+        self._update_font()
+
+    def _update_font(self):
+        self._font = self._font_manager.get_font(self._face, self._bold, self._italic)
+        self.update()
+
+
+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