Writing text in a gloo canvas (vispy.app.canvas) about vispy HOT 11 CLOSED

visual.transforms.configure()

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
import vispy.app
import vispy.color
import vispy.visuals

class Canvas(vispy.app.Canvas):
    def __init__(self):
        super().__init__(size = (600,600), parent=None)
        self.context.set_clear_color(vispy.color.Color("#ffffff"))
        self.text_visual = vispy.visuals.TextVisual("1a 1b", pos=(self.size[0]/2, self.size[1]/2))
        # This is the important line here
        self.text_visual.transforms.configure(canvas=self)

    def on_draw(self, event):
        vispy.gloo.clear()
        self.text_visual.draw()

    def on_resize(self, event):
        # This will keep the text visual position and size when resizing the canvas
        self.text_visual.transforms.configure(canvas=self)

if __name__ == "__main__":
    app = QApplication([])
    win = QMainWindow()
    canvas = Canvas()
    win.setCentralWidget(canvas.native)
    win.show()
    QApplication.instance().exec()

# Shaders
vertex = """
        uniform mat4 projection;
        attribute vec2 position;
        void main()
        {
            gl_Position = projection * vec4(position, 0.0, 1.0);
        } """
fragment = """
        uniform vec3 color;
        void main()
        {
            gl_FragColor = vec4(color, 1);
        } """

# Signals
# Time selection
startTime_index = bisect_left(self.time_vector, self.horizontal_scope[0])
endTime_index = bisect_left(self.time_vector, self.horizontal_scope[1])
selected_time_indexes = np.arange(startTime_index, endTime_index, dtype=np.uint32)
# Signals
self.signals_shaders_list = []
self.signals_status_list = []
for i in range(self.channels_number):
    shader = gloo.Program(vertex, fragment)
    # Position
    pos = np.stack([self.time_vector[selected_time_indexes], self.data[i, selected_time_indexes] * self.gain_factor - i * self.spacing * self.spacing_factor], axis=1)
    shader['position'] = pos
    self.signals_shaders_list.append(shader)
    # Status and color
    status = False
    shader['color'] = (0, 0, 0)
    self.signals_status_list.append(status)
# Projection
projection = util.transforms.ortho(self.horizontal_scope[0], self.horizontal_scope[1], self.vertical_scope[0], self.vertical_scope[1], 0, 1)
for shader in self.signals_shaders_list:
    shader['projection'] = projection

class TextVisual_ductTaped(TextVisual):
    # Init
    def __init__(self, canvas, 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):
        super().__init__(text, color, bold, italic, face, font_size, pos, rotation, anchor_x, anchor_y, method, font_manager, depth_test)
        self.unfreeze()
        self.canvas = canvas
        self.freeze()

    # _prepare_draw override
    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
        #tr = transforms.get_transform('document', 'render')
        #px_scale = (tr.map((1, 0)) - tr.map((0, 1)))[:2]
        n_pix = (self._font_size / 72.) * self.canvas.dpi  # logical pix
        self._text_scale.scale = self.canvas._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 on_resize(self, event):
  # This will keep the text visual position and size when resizing the canvas
  self.text_visual.pos = (self.size[0] / 2, self.size[1] / 2)
  self.text_visual.transforms.configure(canvas=self)