-
-
Notifications
You must be signed in to change notification settings - Fork 7.5k
/
backend_bases.py
3492 lines (2939 loc) · 124 KB
/
backend_bases.py
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
"""
Abstract base classes define the primitives that renderers and
graphics contexts must implement to serve as a Matplotlib backend.
`RendererBase`
An abstract base class to handle drawing/rendering operations.
`FigureCanvasBase`
The abstraction layer that separates the `.Figure` from the backend
specific details like a user interface drawing area.
`GraphicsContextBase`
An abstract base class that provides color, line styles, etc.
`Event`
The base class for all of the Matplotlib event handling. Derived classes
such as `KeyEvent` and `MouseEvent` store the meta data like keys and
buttons pressed, x and y locations in pixel and `~.axes.Axes` coordinates.
`ShowBase`
The base class for the ``Show`` class of each interactive backend; the
'show' callable is then set to ``Show.__call__``.
`ToolContainerBase`
The base class for the Toolbar class of each interactive backend.
"""
from collections import namedtuple
from contextlib import ExitStack, contextmanager, nullcontext
from enum import Enum, IntEnum
import functools
import importlib
import inspect
import io
import itertools
import logging
import os
import sys
import time
import weakref
from weakref import WeakKeyDictionary
import numpy as np
import matplotlib as mpl
from matplotlib import (
_api, backend_tools as tools, cbook, colors, _docstring, text,
_tight_bbox, transforms, widgets, is_interactive, rcParams)
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_managers import ToolManager
from matplotlib.cbook import _setattr_cm
from matplotlib.layout_engine import ConstrainedLayoutEngine
from matplotlib.path import Path
from matplotlib.texmanager import TexManager
from matplotlib.transforms import Affine2D
from matplotlib._enums import JoinStyle, CapStyle
_log = logging.getLogger(__name__)
_default_filetypes = {
'eps': 'Encapsulated Postscript',
'jpg': 'Joint Photographic Experts Group',
'jpeg': 'Joint Photographic Experts Group',
'pdf': 'Portable Document Format',
'pgf': 'PGF code for LaTeX',
'png': 'Portable Network Graphics',
'ps': 'Postscript',
'raw': 'Raw RGBA bitmap',
'rgba': 'Raw RGBA bitmap',
'svg': 'Scalable Vector Graphics',
'svgz': 'Scalable Vector Graphics',
'tif': 'Tagged Image File Format',
'tiff': 'Tagged Image File Format',
'webp': 'WebP Image Format',
}
_default_backends = {
'eps': 'matplotlib.backends.backend_ps',
'jpg': 'matplotlib.backends.backend_agg',
'jpeg': 'matplotlib.backends.backend_agg',
'pdf': 'matplotlib.backends.backend_pdf',
'pgf': 'matplotlib.backends.backend_pgf',
'png': 'matplotlib.backends.backend_agg',
'ps': 'matplotlib.backends.backend_ps',
'raw': 'matplotlib.backends.backend_agg',
'rgba': 'matplotlib.backends.backend_agg',
'svg': 'matplotlib.backends.backend_svg',
'svgz': 'matplotlib.backends.backend_svg',
'tif': 'matplotlib.backends.backend_agg',
'tiff': 'matplotlib.backends.backend_agg',
'webp': 'matplotlib.backends.backend_agg',
}
def _safe_pyplot_import():
"""
Import and return ``pyplot``, correctly setting the backend if one is
already forced.
"""
try:
import matplotlib.pyplot as plt
except ImportError: # Likely due to a framework mismatch.
current_framework = cbook._get_running_interactive_framework()
if current_framework is None:
raise # No, something else went wrong, likely with the install...
backend_mapping = {
'qt': 'qtagg',
'gtk3': 'gtk3agg',
'gtk4': 'gtk4agg',
'wx': 'wxagg',
'tk': 'tkagg',
'macosx': 'macosx',
'headless': 'agg',
}
backend = backend_mapping[current_framework]
rcParams["backend"] = mpl.rcParamsOrig["backend"] = backend
import matplotlib.pyplot as plt # Now this should succeed.
return plt
def register_backend(format, backend, description=None):
"""
Register a backend for saving to a given file format.
Parameters
----------
format : str
File extension
backend : module string or canvas class
Backend for handling file output
description : str, default: ""
Description of the file type.
"""
if description is None:
description = ''
_default_backends[format] = backend
_default_filetypes[format] = description
def get_registered_canvas_class(format):
"""
Return the registered default canvas for given file format.
Handles deferred import of required backend.
"""
if format not in _default_backends:
return None
backend_class = _default_backends[format]
if isinstance(backend_class, str):
backend_class = importlib.import_module(backend_class).FigureCanvas
_default_backends[format] = backend_class
return backend_class
class RendererBase:
"""
An abstract base class to handle drawing/rendering operations.
The following methods must be implemented in the backend for full
functionality (though just implementing `draw_path` alone would give a
highly capable backend):
* `draw_path`
* `draw_image`
* `draw_gouraud_triangles`
The following methods *should* be implemented in the backend for
optimization reasons:
* `draw_text`
* `draw_markers`
* `draw_path_collection`
* `draw_quad_mesh`
"""
def __init__(self):
super().__init__()
self._texmanager = None
self._text2path = text.TextToPath()
self._raster_depth = 0
self._rasterizing = False
def open_group(self, s, gid=None):
"""
Open a grouping element with label *s* and *gid* (if set) as id.
Only used by the SVG renderer.
"""
def close_group(self, s):
"""
Close a grouping element with label *s*.
Only used by the SVG renderer.
"""
def draw_path(self, gc, path, transform, rgbFace=None):
"""Draw a `~.path.Path` instance using the given affine transform."""
raise NotImplementedError
def draw_markers(self, gc, marker_path, marker_trans, path,
trans, rgbFace=None):
"""
Draw a marker at each of *path*'s vertices (excluding control points).
The base (fallback) implementation makes multiple calls to `draw_path`.
Backends may want to override this method in order to draw the marker
only once and reuse it multiple times.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
marker_path : `~matplotlib.path.Path`
The path for the marker.
marker_trans : `~matplotlib.transforms.Transform`
An affine transform applied to the marker.
path : `~matplotlib.path.Path`
The locations to draw the markers.
trans : `~matplotlib.transforms.Transform`
An affine transform applied to the path.
rgbFace : color, optional
"""
for vertices, codes in path.iter_segments(trans, simplify=False):
if len(vertices):
x, y = vertices[-2:]
self.draw_path(gc, marker_path,
marker_trans +
transforms.Affine2D().translate(x, y),
rgbFace)
def draw_path_collection(self, gc, master_transform, paths, all_transforms,
offsets, offset_trans, facecolors, edgecolors,
linewidths, linestyles, antialiaseds, urls,
offset_position):
"""
Draw a collection of *paths*.
Each path is first transformed by the corresponding entry
in *all_transforms* (a list of (3, 3) matrices) and then by
*master_transform*. They are then translated by the corresponding
entry in *offsets*, which has been first transformed by *offset_trans*.
*facecolors*, *edgecolors*, *linewidths*, *linestyles*, and
*antialiased* are lists that set the corresponding properties.
*offset_position* is unused now, but the argument is kept for
backwards compatibility.
The base (fallback) implementation makes multiple calls to `draw_path`.
Backends may want to override this in order to render each set of
path data only once, and then reference that path multiple times with
the different offsets, colors, styles etc. The generator methods
`_iter_collection_raw_paths` and `_iter_collection` are provided to
help with (and standardize) the implementation across backends. It
is highly recommended to use those generators, so that changes to the
behavior of `draw_path_collection` can be made globally.
"""
path_ids = self._iter_collection_raw_paths(master_transform,
paths, all_transforms)
for xo, yo, path_id, gc0, rgbFace in self._iter_collection(
gc, list(path_ids), offsets, offset_trans,
facecolors, edgecolors, linewidths, linestyles,
antialiaseds, urls, offset_position):
path, transform = path_id
# Only apply another translation if we have an offset, else we
# reuse the initial transform.
if xo != 0 or yo != 0:
# The transformation can be used by multiple paths. Since
# translate is a inplace operation, we need to copy the
# transformation by .frozen() before applying the translation.
transform = transform.frozen()
transform.translate(xo, yo)
self.draw_path(gc0, path, transform, rgbFace)
def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
coordinates, offsets, offsetTrans, facecolors,
antialiased, edgecolors):
"""
Draw a quadmesh.
The base (fallback) implementation converts the quadmesh to paths and
then calls `draw_path_collection`.
"""
from matplotlib.collections import QuadMesh
paths = QuadMesh._convert_mesh_to_paths(coordinates)
if edgecolors is None:
edgecolors = facecolors
linewidths = np.array([gc.get_linewidth()], float)
return self.draw_path_collection(
gc, master_transform, paths, [], offsets, offsetTrans, facecolors,
edgecolors, linewidths, [], [antialiased], [None], 'screen')
@_api.deprecated("3.7", alternative="draw_gouraud_triangles")
def draw_gouraud_triangle(self, gc, points, colors, transform):
"""
Draw a Gouraud-shaded triangle.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
points : (3, 2) array-like
Array of (x, y) points for the triangle.
colors : (3, 4) array-like
RGBA colors for each point of the triangle.
transform : `~matplotlib.transforms.Transform`
An affine transform to apply to the points.
"""
raise NotImplementedError
def draw_gouraud_triangles(self, gc, triangles_array, colors_array,
transform):
"""
Draw a series of Gouraud triangles.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
triangles_array : (N, 3, 2) array-like
Array of *N* (x, y) points for the triangles.
colors_array : (N, 3, 4) array-like
Array of *N* RGBA colors for each point of the triangles.
transform : `~matplotlib.transforms.Transform`
An affine transform to apply to the points.
"""
raise NotImplementedError
def _iter_collection_raw_paths(self, master_transform, paths,
all_transforms):
"""
Helper method (along with `_iter_collection`) to implement
`draw_path_collection` in a memory-efficient manner.
This method yields all of the base path/transform combinations, given a
master transform, a list of paths and list of transforms.
The arguments should be exactly what is passed in to
`draw_path_collection`.
The backend should take each yielded path and transform and create an
object that can be referenced (reused) later.
"""
Npaths = len(paths)
Ntransforms = len(all_transforms)
N = max(Npaths, Ntransforms)
if Npaths == 0:
return
transform = transforms.IdentityTransform()
for i in range(N):
path = paths[i % Npaths]
if Ntransforms:
transform = Affine2D(all_transforms[i % Ntransforms])
yield path, transform + master_transform
def _iter_collection_uses_per_path(self, paths, all_transforms,
offsets, facecolors, edgecolors):
"""
Compute how many times each raw path object returned by
`_iter_collection_raw_paths` would be used when calling
`_iter_collection`. This is intended for the backend to decide
on the tradeoff between using the paths in-line and storing
them once and reusing. Rounds up in case the number of uses
is not the same for every path.
"""
Npaths = len(paths)
if Npaths == 0 or len(facecolors) == len(edgecolors) == 0:
return 0
Npath_ids = max(Npaths, len(all_transforms))
N = max(Npath_ids, len(offsets))
return (N + Npath_ids - 1) // Npath_ids
def _iter_collection(self, gc, path_ids, offsets, offset_trans, facecolors,
edgecolors, linewidths, linestyles,
antialiaseds, urls, offset_position):
"""
Helper method (along with `_iter_collection_raw_paths`) to implement
`draw_path_collection` in a memory-efficient manner.
This method yields all of the path, offset and graphics context
combinations to draw the path collection. The caller should already
have looped over the results of `_iter_collection_raw_paths` to draw
this collection.
The arguments should be the same as that passed into
`draw_path_collection`, with the exception of *path_ids*, which is a
list of arbitrary objects that the backend will use to reference one of
the paths created in the `_iter_collection_raw_paths` stage.
Each yielded result is of the form::
xo, yo, path_id, gc, rgbFace
where *xo*, *yo* is an offset; *path_id* is one of the elements of
*path_ids*; *gc* is a graphics context and *rgbFace* is a color to
use for filling the path.
"""
Npaths = len(path_ids)
Noffsets = len(offsets)
N = max(Npaths, Noffsets)
Nfacecolors = len(facecolors)
Nedgecolors = len(edgecolors)
Nlinewidths = len(linewidths)
Nlinestyles = len(linestyles)
Nurls = len(urls)
if (Nfacecolors == 0 and Nedgecolors == 0) or Npaths == 0:
return
gc0 = self.new_gc()
gc0.copy_properties(gc)
def cycle_or_default(seq, default=None):
# Cycle over *seq* if it is not empty; else always yield *default*.
return (itertools.cycle(seq) if len(seq)
else itertools.repeat(default))
pathids = cycle_or_default(path_ids)
toffsets = cycle_or_default(offset_trans.transform(offsets), (0, 0))
fcs = cycle_or_default(facecolors)
ecs = cycle_or_default(edgecolors)
lws = cycle_or_default(linewidths)
lss = cycle_or_default(linestyles)
aas = cycle_or_default(antialiaseds)
urls = cycle_or_default(urls)
if Nedgecolors == 0:
gc0.set_linewidth(0.0)
for pathid, (xo, yo), fc, ec, lw, ls, aa, url in itertools.islice(
zip(pathids, toffsets, fcs, ecs, lws, lss, aas, urls), N):
if not (np.isfinite(xo) and np.isfinite(yo)):
continue
if Nedgecolors:
if Nlinewidths:
gc0.set_linewidth(lw)
if Nlinestyles:
gc0.set_dashes(*ls)
if len(ec) == 4 and ec[3] == 0.0:
gc0.set_linewidth(0)
else:
gc0.set_foreground(ec)
if fc is not None and len(fc) == 4 and fc[3] == 0:
fc = None
gc0.set_antialiased(aa)
if Nurls:
gc0.set_url(url)
yield xo, yo, pathid, gc0, fc
gc0.restore()
def get_image_magnification(self):
"""
Get the factor by which to magnify images passed to `draw_image`.
Allows a backend to have images at a different resolution to other
artists.
"""
return 1.0
def draw_image(self, gc, x, y, im, transform=None):
"""
Draw an RGBA image.
Parameters
----------
gc : `.GraphicsContextBase`
A graphics context with clipping information.
x : scalar
The distance in physical units (i.e., dots or pixels) from the left
hand side of the canvas.
y : scalar
The distance in physical units (i.e., dots or pixels) from the
bottom side of the canvas.
im : (N, M, 4) array of `numpy.uint8`
An array of RGBA pixels.
transform : `~matplotlib.transforms.Affine2DBase`
If and only if the concrete backend is written such that
`option_scale_image` returns ``True``, an affine transformation
(i.e., an `.Affine2DBase`) *may* be passed to `draw_image`. The
translation vector of the transformation is given in physical units
(i.e., dots or pixels). Note that the transformation does not
override *x* and *y*, and has to be applied *before* translating
the result by *x* and *y* (this can be accomplished by adding *x*
and *y* to the translation vector defined by *transform*).
"""
raise NotImplementedError
def option_image_nocomposite(self):
"""
Return whether image composition by Matplotlib should be skipped.
Raster backends should usually return False (letting the C-level
rasterizer take care of image composition); vector backends should
usually return ``not rcParams["image.composite_image"]``.
"""
return False
def option_scale_image(self):
"""
Return whether arbitrary affine transformations in `draw_image` are
supported (True for most vector backends).
"""
return False
def draw_tex(self, gc, x, y, s, prop, angle, *, mtext=None):
"""
Draw a TeX instance.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
x : float
The x location of the text in display coords.
y : float
The y location of the text baseline in display coords.
s : str
The TeX text string.
prop : `~matplotlib.font_manager.FontProperties`
The font properties.
angle : float
The rotation angle in degrees anti-clockwise.
mtext : `~matplotlib.text.Text`
The original text object to be rendered.
"""
self._draw_text_as_path(gc, x, y, s, prop, angle, ismath="TeX")
def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
"""
Draw a text instance.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
x : float
The x location of the text in display coords.
y : float
The y location of the text baseline in display coords.
s : str
The text string.
prop : `~matplotlib.font_manager.FontProperties`
The font properties.
angle : float
The rotation angle in degrees anti-clockwise.
ismath : bool or "TeX"
If True, use mathtext parser. If "TeX", use tex for rendering.
mtext : `~matplotlib.text.Text`
The original text object to be rendered.
Notes
-----
**Note for backend implementers:**
When you are trying to determine if you have gotten your bounding box
right (which is what enables the text layout/alignment to work
properly), it helps to change the line in text.py::
if 0: bbox_artist(self, renderer)
to if 1, and then the actual bounding box will be plotted along with
your text.
"""
self._draw_text_as_path(gc, x, y, s, prop, angle, ismath)
def _get_text_path_transform(self, x, y, s, prop, angle, ismath):
"""
Return the text path and transform.
Parameters
----------
x : float
The x location of the text in display coords.
y : float
The y location of the text baseline in display coords.
s : str
The text to be converted.
prop : `~matplotlib.font_manager.FontProperties`
The font property.
angle : float
Angle in degrees to render the text at.
ismath : bool or "TeX"
If True, use mathtext parser. If "TeX", use tex for rendering.
"""
text2path = self._text2path
fontsize = self.points_to_pixels(prop.get_size_in_points())
verts, codes = text2path.get_text_path(prop, s, ismath=ismath)
path = Path(verts, codes)
angle = np.deg2rad(angle)
if self.flipy():
width, height = self.get_canvas_width_height()
transform = (Affine2D()
.scale(fontsize / text2path.FONT_SCALE)
.rotate(angle)
.translate(x, height - y))
else:
transform = (Affine2D()
.scale(fontsize / text2path.FONT_SCALE)
.rotate(angle)
.translate(x, y))
return path, transform
def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath):
"""
Draw the text by converting them to paths using `.TextToPath`.
Parameters
----------
gc : `.GraphicsContextBase`
The graphics context.
x : float
The x location of the text in display coords.
y : float
The y location of the text baseline in display coords.
s : str
The text to be converted.
prop : `~matplotlib.font_manager.FontProperties`
The font property.
angle : float
Angle in degrees to render the text at.
ismath : bool or "TeX"
If True, use mathtext parser. If "TeX", use tex for rendering.
"""
path, transform = self._get_text_path_transform(
x, y, s, prop, angle, ismath)
color = gc.get_rgb()
gc.set_linewidth(0.0)
self.draw_path(gc, path, transform, rgbFace=color)
def get_text_width_height_descent(self, s, prop, ismath):
"""
Get the width, height, and descent (offset from the bottom to the baseline), in
display coords, of the string *s* with `.FontProperties` *prop*.
Whitespace at the start and the end of *s* is included in the reported width.
"""
fontsize = prop.get_size_in_points()
if ismath == 'TeX':
# todo: handle properties
return self.get_texmanager().get_text_width_height_descent(
s, fontsize, renderer=self)
dpi = self.points_to_pixels(72)
if ismath:
dims = self._text2path.mathtext_parser.parse(s, dpi, prop)
return dims[0:3] # return width, height, descent
flags = self._text2path._get_hinting_flag()
font = self._text2path._get_font(prop)
font.set_size(fontsize, dpi)
# the width and height of unrotated string
font.set_text(s, 0.0, flags=flags)
w, h = font.get_width_height()
d = font.get_descent()
w /= 64.0 # convert from subpixels
h /= 64.0
d /= 64.0
return w, h, d
def flipy(self):
"""
Return whether y values increase from top to bottom.
Note that this only affects drawing of texts.
"""
return True
def get_canvas_width_height(self):
"""Return the canvas width and height in display coords."""
return 1, 1
def get_texmanager(self):
"""Return the `.TexManager` instance."""
if self._texmanager is None:
self._texmanager = TexManager()
return self._texmanager
def new_gc(self):
"""Return an instance of a `.GraphicsContextBase`."""
return GraphicsContextBase()
def points_to_pixels(self, points):
"""
Convert points to display units.
You need to override this function (unless your backend
doesn't have a dpi, e.g., postscript or svg). Some imaging
systems assume some value for pixels per inch::
points to pixels = points * pixels_per_inch/72 * dpi/72
Parameters
----------
points : float or array-like
Returns
-------
Points converted to pixels
"""
return points
def start_rasterizing(self):
"""
Switch to the raster renderer.
Used by `.MixedModeRenderer`.
"""
def stop_rasterizing(self):
"""
Switch back to the vector renderer and draw the contents of the raster
renderer as an image on the vector renderer.
Used by `.MixedModeRenderer`.
"""
def start_filter(self):
"""
Switch to a temporary renderer for image filtering effects.
Currently only supported by the agg renderer.
"""
def stop_filter(self, filter_func):
"""
Switch back to the original renderer. The contents of the temporary
renderer is processed with the *filter_func* and is drawn on the
original renderer as an image.
Currently only supported by the agg renderer.
"""
def _draw_disabled(self):
"""
Context manager to temporary disable drawing.
This is used for getting the drawn size of Artists. This lets us
run the draw process to update any Python state but does not pay the
cost of the draw_XYZ calls on the canvas.
"""
no_ops = {
meth_name: lambda *args, **kwargs: None
for meth_name in dir(RendererBase)
if (meth_name.startswith("draw_")
or meth_name in ["open_group", "close_group"])
}
return _setattr_cm(self, **no_ops)
class GraphicsContextBase:
"""An abstract base class that provides color, line styles, etc."""
def __init__(self):
self._alpha = 1.0
self._forced_alpha = False # if True, _alpha overrides A from RGBA
self._antialiased = 1 # use 0, 1 not True, False for extension code
self._capstyle = CapStyle('butt')
self._cliprect = None
self._clippath = None
self._dashes = 0, None
self._joinstyle = JoinStyle('round')
self._linestyle = 'solid'
self._linewidth = 1
self._rgb = (0.0, 0.0, 0.0, 1.0)
self._hatch = None
self._hatch_color = colors.to_rgba(rcParams['hatch.color'])
self._hatch_linewidth = rcParams['hatch.linewidth']
self._url = None
self._gid = None
self._snap = None
self._sketch = None
def copy_properties(self, gc):
"""Copy properties from *gc* to self."""
self._alpha = gc._alpha
self._forced_alpha = gc._forced_alpha
self._antialiased = gc._antialiased
self._capstyle = gc._capstyle
self._cliprect = gc._cliprect
self._clippath = gc._clippath
self._dashes = gc._dashes
self._joinstyle = gc._joinstyle
self._linestyle = gc._linestyle
self._linewidth = gc._linewidth
self._rgb = gc._rgb
self._hatch = gc._hatch
self._hatch_color = gc._hatch_color
self._hatch_linewidth = gc._hatch_linewidth
self._url = gc._url
self._gid = gc._gid
self._snap = gc._snap
self._sketch = gc._sketch
def restore(self):
"""
Restore the graphics context from the stack - needed only
for backends that save graphics contexts on a stack.
"""
def get_alpha(self):
"""
Return the alpha value used for blending - not supported on all
backends.
"""
return self._alpha
def get_antialiased(self):
"""Return whether the object should try to do antialiased rendering."""
return self._antialiased
def get_capstyle(self):
"""Return the `.CapStyle`."""
return self._capstyle.name
def get_clip_rectangle(self):
"""
Return the clip rectangle as a `~matplotlib.transforms.Bbox` instance.
"""
return self._cliprect
def get_clip_path(self):
"""
Return the clip path in the form (path, transform), where path
is a `~.path.Path` instance, and transform is
an affine transform to apply to the path before clipping.
"""
if self._clippath is not None:
tpath, tr = self._clippath.get_transformed_path_and_affine()
if np.all(np.isfinite(tpath.vertices)):
return tpath, tr
else:
_log.warning("Ill-defined clip_path detected. Returning None.")
return None, None
return None, None
def get_dashes(self):
"""
Return the dash style as an (offset, dash-list) pair.
See `.set_dashes` for details.
Default value is (None, None).
"""
return self._dashes
def get_forced_alpha(self):
"""
Return whether the value given by get_alpha() should be used to
override any other alpha-channel values.
"""
return self._forced_alpha
def get_joinstyle(self):
"""Return the `.JoinStyle`."""
return self._joinstyle.name
def get_linewidth(self):
"""Return the line width in points."""
return self._linewidth
def get_rgb(self):
"""Return a tuple of three or four floats from 0-1."""
return self._rgb
def get_url(self):
"""Return a url if one is set, None otherwise."""
return self._url
def get_gid(self):
"""Return the object identifier if one is set, None otherwise."""
return self._gid
def get_snap(self):
"""
Return the snap setting, which can be:
* True: snap vertices to the nearest pixel center
* False: leave vertices as-is
* None: (auto) If the path contains only rectilinear line segments,
round to the nearest pixel center
"""
return self._snap
def set_alpha(self, alpha):
"""
Set the alpha value used for blending - not supported on all backends.
If ``alpha=None`` (the default), the alpha components of the
foreground and fill colors will be used to set their respective
transparencies (where applicable); otherwise, ``alpha`` will override
them.
"""
if alpha is not None:
self._alpha = alpha
self._forced_alpha = True
else:
self._alpha = 1.0
self._forced_alpha = False
self.set_foreground(self._rgb, isRGBA=True)
def set_antialiased(self, b):
"""Set whether object should be drawn with antialiased rendering."""
# Use ints to make life easier on extension code trying to read the gc.
self._antialiased = int(bool(b))
@_docstring.interpd
def set_capstyle(self, cs):
"""
Set how to draw endpoints of lines.
Parameters
----------
cs : `.CapStyle` or %(CapStyle)s
"""
self._capstyle = CapStyle(cs)
def set_clip_rectangle(self, rectangle):
"""Set the clip rectangle to a `.Bbox` or None."""
self._cliprect = rectangle
def set_clip_path(self, path):
"""Set the clip path to a `.TransformedPath` or None."""
_api.check_isinstance((transforms.TransformedPath, None), path=path)
self._clippath = path
def set_dashes(self, dash_offset, dash_list):
"""
Set the dash style for the gc.
Parameters
----------
dash_offset : float
Distance, in points, into the dash pattern at which to
start the pattern. It is usually set to 0.
dash_list : array-like or None
The on-off sequence as points. None specifies a solid line. All
values must otherwise be non-negative (:math:`\\ge 0`).
Notes
-----
See p. 666 of the PostScript
`Language Reference
<https://www.adobe.com/jp/print/postscript/pdfs/PLRM.pdf>`_
for more info.
"""
if dash_list is not None:
dl = np.asarray(dash_list)
if np.any(dl < 0.0):
raise ValueError(
"All values in the dash list must be non-negative")
if dl.size and not np.any(dl > 0.0):
raise ValueError(
'At least one value in the dash list must be positive')
self._dashes = dash_offset, dash_list
def set_foreground(self, fg, isRGBA=False):
"""
Set the foreground color.
Parameters
----------
fg : color
isRGBA : bool
If *fg* is known to be an ``(r, g, b, a)`` tuple, *isRGBA* can be
set to True to improve performance.
"""
if self._forced_alpha and isRGBA:
self._rgb = fg[:3] + (self._alpha,)
elif self._forced_alpha:
self._rgb = colors.to_rgba(fg, self._alpha)
elif isRGBA:
self._rgb = fg
else:
self._rgb = colors.to_rgba(fg)
@_docstring.interpd
def set_joinstyle(self, js):
"""
Set how to draw connections between line segments.
Parameters
----------
js : `.JoinStyle` or %(JoinStyle)s
"""
self._joinstyle = JoinStyle(js)
def set_linewidth(self, w):