from io import BytesIO

import platform

import numpy as np

from matplotlib.testing.decorators import image_comparison

import matplotlib.pyplot as plt

import matplotlib.path as mpath

import matplotlib.patches as mpatches

from matplotlib.ticker import FuncFormatter

from mpl_toolkits.axes_grid1.inset_locator import inset_axes

@image_comparison(['bbox_inches_tight'], remove_text=True, style='mpl20',

savefig_kwarg={'bbox_inches': 'tight'})

def test_bbox_inches_tight(text_placeholders):

#: Test that a figure saved using bbox_inches='tight' is clipped correctly

data = [[66386, 174296, 75131, 577908, 32015],

[58230, 381139, 78045, 99308, 160454],

[89135, 80552, 152558, 497981, 603535],

[78415, 81858, 150656, 193263, 69638],

[139361, 331509, 343164, 781380, 52269]]

col_labels = ('Freeze', 'Wind', 'Flood', 'Quake', 'Hail')

row_labels = [f'{x} year' for x in (100, 50, 20, 10, 5)]

rows = len(data)

ind = np.arange(len(col_labels)) + 0.3 # the x locations for the groups

cell_text = []

width = 0.4 # the width of the bars

yoff = np.zeros(len(col_labels))

# the bottom values for stacked bar chart

fig, ax = plt.subplots(1, 1)

for row in range(rows):

ax.bar(ind, data[row], width, bottom=yoff, align='edge')

yoff = yoff + data[row]

cell_text.append([f'{x / 1000:1.1f}' for x in yoff])

plt.xticks([])

plt.xlim(0, 5)

plt.legend(['1', '2', '3', '4', '5'], loc=(1.2, 0.2))

fig.legend(['a', 'b', 'c', 'd', 'e'], bbox_to_anchor=(0, 0.2), loc='lower left')

# Add a table at the bottom of the axes

cell_text.reverse()

plt.table(cellText=cell_text, rowLabels=row_labels, colLabels=col_labels,

loc='bottom')

@image_comparison(['bbox_inches_tight_suptile_legend'],

savefig_kwarg={'bbox_inches': 'tight'},

tol=0 if platform.machine() == 'x86_64' else 0.02)

def test_bbox_inches_tight_suptile_legend():

plt.plot(np.arange(10), label='a straight line')

plt.legend(bbox_to_anchor=(0.9, 1), loc='upper left')

plt.title('Axis title')

plt.suptitle('Figure title')

# put an extra long y tick on to see that the bbox is accounted for

def y_formatter(y, pos):

if int(y) == 4:

return 'The number 4'

else:

return str(y)

plt.gca().yaxis.set_major_formatter(FuncFormatter(y_formatter))

plt.xlabel('X axis')

@image_comparison(['bbox_inches_tight_suptile_non_default.png'],

savefig_kwarg={'bbox_inches': 'tight'},

tol=0.1) # large tolerance because only testing clipping.

def test_bbox_inches_tight_suptitle_non_default():

fig, ax = plt.subplots()

fig.suptitle('Booo', x=0.5, y=1.1)

@image_comparison(['bbox_inches_tight_layout.png'], remove_text=True,

style='mpl20',

savefig_kwarg=dict(bbox_inches='tight', pad_inches='layout'))

def test_bbox_inches_tight_layout_constrained():

fig, ax = plt.subplots(layout='constrained')

fig.get_layout_engine().set(h_pad=0.5)

ax.set_aspect('equal')

def test_bbox_inches_tight_layout_notconstrained(tmp_path):

# pad_inches='layout' should be ignored when not using constrained/

# compressed layout. Smoke test that savefig doesn't error in this case.

fig, ax = plt.subplots()

fig.savefig(tmp_path / 'foo.png', bbox_inches='tight', pad_inches='layout')

@image_comparison(['bbox_inches_tight_clipping'],

remove_text=True, savefig_kwarg={'bbox_inches': 'tight'})

def test_bbox_inches_tight_clipping():

# tests bbox clipping on scatter points, and path clipping on a patch

# to generate an appropriately tight bbox

plt.scatter(np.arange(10), np.arange(10))

ax = plt.gca()

ax.set_xlim(0, 5)

ax.set_ylim(0, 5)

# make a massive rectangle and clip it with a path

patch = mpatches.Rectangle([-50, -50], 100, 100,

transform=ax.transData,

facecolor='blue', alpha=0.5)

path = mpath.Path.unit_regular_star(5).deepcopy()

path.vertices *= 0.25

patch.set_clip_path(path, transform=ax.transAxes)

plt.gcf().artists.append(patch)

@image_comparison(['bbox_inches_tight_raster'], tol=0.15, # For Ghostscript 10.06+.

remove_text=True, savefig_kwarg={'bbox_inches': 'tight'})

def test_bbox_inches_tight_raster():

"""Test rasterization with tight_layout"""

fig, ax = plt.subplots()

ax.plot([1.0, 2.0], rasterized=True)

def test_only_on_non_finite_bbox():

fig, ax = plt.subplots()

ax.annotate("", xy=(0, float('nan')))

ax.set_axis_off()

# we only need to test that it does not error out on save

fig.savefig(BytesIO(), bbox_inches='tight', format='png')

def test_tight_pcolorfast():

fig, ax = plt.subplots()

ax.pcolorfast(np.arange(4).reshape((2, 2)))

ax.set(ylim=(0, .1))

buf = BytesIO()

fig.savefig(buf, bbox_inches="tight")

buf.seek(0)

height, width, _ = plt.imread(buf).shape

# Previously, the bbox would include the area of the image clipped out by

# the axes, resulting in a very tall image given the y limits of (0, 0.1).

assert width > height

def test_noop_tight_bbox():

from PIL import Image

x_size, y_size = (10, 7)

dpi = 100

# make the figure just the right size up front

fig = plt.figure(frameon=False, dpi=dpi, figsize=(x_size/dpi, y_size/dpi))

ax = fig.add_axes((0, 0, 1, 1))

ax.set_axis_off()

ax.xaxis.set_visible(False)

ax.yaxis.set_visible(False)

data = np.arange(x_size * y_size).reshape(y_size, x_size)

ax.imshow(data, rasterized=True)

# When a rasterized Artist is included, a mixed-mode renderer does

# additional bbox adjustment. It should also be a no-op, and not affect the

# next save.

fig.savefig(BytesIO(), bbox_inches='tight', pad_inches=0, format='pdf')

out = BytesIO()

fig.savefig(out, bbox_inches='tight', pad_inches=0)

out.seek(0)

im = np.asarray(Image.open(out))

assert (im[:, :, 3] == 255).all()

assert not (im[:, :, :3] == 255).all()

assert im.shape == (7, 10, 4)

@image_comparison(['bbox_inches_fixed_aspect.png'], remove_text=True,

savefig_kwarg={'bbox_inches': 'tight'})

def test_bbox_inches_fixed_aspect():

with plt.rc_context({'figure.constrained_layout.use': True}):

fig, ax = plt.subplots()

ax.plot([0, 1])

ax.set_xlim(0, 1)

ax.set_aspect('equal')

@image_comparison(['bbox_inches_inset_rasterized.pdf'], remove_text=True,

savefig_kwarg={'bbox_inches': 'tight'}, style='mpl20')

def test_bbox_inches_inset_rasterized():

fig, ax = plt.subplots()

arr = np.arange(100).reshape(10, 10)

im = ax.imshow(arr)

inset = inset_axes(

ax, width='10%', height='30%', loc='upper left',

bbox_to_anchor=(0.045, 0., 1, 1), bbox_transform=ax.transAxes)

fig.colorbar(im, cax=inset, orientation='horizontal')