FlatCAM/VisPyPatches.py at master · dielectric-coder/FlatCAM · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
from vispy.visuals import markers, LineVisual, InfiniteLineVisual
from vispy.scene.widgets import Grid
import numpy as np


def apply_patches():
    # Patch MarkersVisual to have crossed lines marker (VisPy < 0.9)
    cross_lines = """
    float cross(vec2 pointcoord, float size)
    {
        //vbar
        float r1 = abs(pointcoord.x - 0.5)*size;
        float r2 = abs(pointcoord.y - 0.5)*size - $v_size/2;
        float vbar = max(r1,r2);
        //hbar
        float r3 = abs(pointcoord.y - 0.5)*size;
        float r4 = abs(pointcoord.x - 0.5)*size - $v_size/2;
        float hbar = max(r3,r4);
        return min(vbar, hbar);
    }
    """

    if hasattr(markers, '_marker_dict'):
        markers._marker_dict['++'] = cross_lines
        markers.marker_types = tuple(sorted(list(markers._marker_dict.keys())))

    # Patch VisPy Grid to prevent updating layout on PaintGL, which cause low fps
    def _prepare_draw(self, view):
        pass

    def _update_clipper(self):
        super(Grid, self)._update_clipper()
        try:
            self._update_child_widget_dim()
        except Exception as e:
            print(e)

    Grid._prepare_draw = _prepare_draw
    Grid._update_clipper = _update_clipper

    # Patch InfiniteLine visual to 1px width (only if internal API available)
    if hasattr(InfiniteLineVisual, '_changed'):
        def _inf_line_prepare_draw(self, view=None):
            GL = None
            from vispy.app._default_app import default_app

            if default_app is not None and \
                    default_app.backend_name != 'ipynb_webgl':
                try:
                    import OpenGL.GL as GL
                except Exception:
                    pass

            if GL:
                GL.glDisable(GL.GL_LINE_SMOOTH)
                GL.glLineWidth(1.0)

            if self._changed['pos']:
                self.pos_buf.set_data(self._pos)
                self._changed['pos'] = False

            if self._changed['color']:
                self._program.vert['color'] = self._color
                self._changed['color'] = False

        InfiniteLineVisual._prepare_draw = _inf_line_prepare_draw

    # Patch AxisVisual to have less axis labels
    try:
        from vispy.visuals.axis import Ticker, _get_ticks_talbot

        def _get_tick_frac_labels(self):
            """Get the major ticks, minor ticks, and major labels"""
            minor_num = 4  # number of minor ticks per major division
            if (self.axis.scale_type == 'linear'):
                domain = self.axis.domain
                if domain[1] < domain[0]:
                    flip = True
                    domain = domain[::-1]
                else:
                    flip = False
                offset = domain[0]
                scale = domain[1] - domain[0]

                transforms = self.axis.transforms
                length = self.axis.pos[1] - self.axis.pos[0]  # in logical coords
                n_inches = np.sqrt(np.sum(length ** 2)) / transforms.dpi

                major = _get_ticks_talbot(domain[0], domain[1], n_inches, 1)

                labels = ['%g' % x for x in major]
                majstep = major[1] - major[0]
                minor = []
                minstep = majstep / (minor_num + 1)
                minstart = 0 if self.axis._stop_at_major[0] else -1
                minstop = -1 if self.axis._stop_at_major[1] else 0
                for i in range(minstart, len(major) + minstop):
                    maj = major[0] + i * majstep
                    minor.extend(np.linspace(maj + minstep,
                                             maj + majstep - minstep,
                                             minor_num))
                major_frac = (major - offset) / scale
                minor_frac = (np.array(minor) - offset) / scale
                major_frac = major_frac[::-1] if flip else major_frac
                use_mask = (major_frac > -0.0001) & (major_frac < 1.0001)
                major_frac = major_frac[use_mask]
                labels = [l for li, l in enumerate(labels) if use_mask[li]]
                minor_frac = minor_frac[(minor_frac > -0.0001) &
                                        (minor_frac < 1.0001)]
            elif self.axis.scale_type == 'logarithmic':
                return NotImplementedError
            elif self.axis.scale_type == 'power':
                return NotImplementedError
            return major_frac, minor_frac, labels

        Ticker._get_tick_frac_labels = _get_tick_frac_labels
    except ImportError:
        pass