FilesExpand file tree

 main

/

_tight_bbox.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

84 lines (68 loc) · 2.75 KB

 main

/

_tight_bbox.py

Copy path

Top

File metadata and controls

• Code
• Blame

84 lines (68 loc) · 2.75 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

"""

Helper module for the *bbox_inches* parameter in `.Figure.savefig`.

"""

from matplotlib.transforms import Bbox, TransformedBbox, Affine2D

def adjust_bbox(fig, bbox_inches, renderer, fixed_dpi=None):

"""

Temporarily adjust the figure so that only the specified area

(bbox_inches) is saved.

It modifies fig.bbox, fig.bbox_inches,

fig.transFigure._boxout, and fig.patch. While the figure size

changes, the scale of the original figure is conserved. A

function which restores the original values are returned.

"""

origBbox = fig.bbox

origBboxInches = fig.bbox_inches

_boxout = fig.transFigure._boxout

old_aspect = []

locator_list = []

sentinel = object()

for ax in fig.axes:

locator = ax.get_axes_locator()

if locator is not None:

ax.apply_aspect(locator(ax, renderer))

locator_list.append(locator)

current_pos = ax.get_position(original=False).frozen()

ax.set_axes_locator(lambda a, r, _pos=current_pos: _pos)

# override the method that enforces the aspect ratio on the Axes

if 'apply_aspect' in ax.__dict__:

old_aspect.append(ax.apply_aspect)

else:

old_aspect.append(sentinel)

ax.apply_aspect = lambda pos=None: None

def restore_bbox():

for ax, loc, aspect in zip(fig.axes, locator_list, old_aspect):

ax.set_axes_locator(loc)

if aspect is sentinel:

# delete our no-op function which un-hides the original method

del ax.apply_aspect

else:

ax.apply_aspect = aspect

fig.bbox = origBbox

fig.bbox_inches = origBboxInches

fig.transFigure._boxout = _boxout

fig.transFigure.invalidate()

fig.patch.set_bounds(0, 0, 1, 1)

if fixed_dpi is None:

fixed_dpi = fig.dpi

tr = Affine2D().scale(fixed_dpi)

dpi_scale = fixed_dpi / fig.dpi

fig.bbox_inches = Bbox.from_bounds(0, 0, *bbox_inches.size)

x0, y0 = tr.transform(bbox_inches.p0)

w1, h1 = fig.bbox.size * dpi_scale

fig.transFigure._boxout = Bbox.from_bounds(-x0, -y0, w1, h1)

fig.transFigure.invalidate()

fig.bbox = TransformedBbox(fig.bbox_inches, tr)

fig.patch.set_bounds(x0 / w1, y0 / h1,

fig.bbox.width / w1, fig.bbox.height / h1)

return restore_bbox

def process_figure_for_rasterizing(fig, bbox_inches_restore, renderer, fixed_dpi=None):

"""

A function that needs to be called when figure dpi changes during the

drawing (e.g., rasterizing). It recovers the bbox and re-adjust it with

the new dpi.

"""

bbox_inches, restore_bbox = bbox_inches_restore

restore_bbox()

r = adjust_bbox(fig, bbox_inches, renderer, fixed_dpi)

return bbox_inches, r