import platform

import pytest

import matplotlib.colors as mcolors

import matplotlib.pyplot as plt

import matplotlib.transforms as mtransforms

from matplotlib.testing.decorators import image_comparison, check_figures_equal

def test_indicate_inset_no_args():

fig, ax = plt.subplots()

with pytest.raises(ValueError, match='At least one of bounds or inset_ax'):

ax.indicate_inset()

@check_figures_equal()

def test_zoom_inset_update_limits(fig_test, fig_ref):

# Updating the inset axes limits should also update the indicator #19768

ax_ref = fig_ref.add_subplot()

ax_test = fig_test.add_subplot()

for ax in ax_ref, ax_test:

ax.set_xlim([0, 5])

ax.set_ylim([0, 5])

inset_ref = ax_ref.inset_axes([0.6, 0.6, 0.3, 0.3])

inset_test = ax_test.inset_axes([0.6, 0.6, 0.3, 0.3])

inset_ref.set_xlim([1, 2])

inset_ref.set_ylim([3, 4])

ax_ref.indicate_inset_zoom(inset_ref)

ax_test.indicate_inset_zoom(inset_test)

inset_test.set_xlim([1, 2])

inset_test.set_ylim([3, 4])

def test_inset_indicator_update_styles():

fig, ax = plt.subplots()

inset = ax.inset_axes([0.6, 0.6, 0.3, 0.3])

inset.set_xlim([0.2, 0.4])

inset.set_ylim([0.2, 0.4])

indicator = ax.indicate_inset_zoom(

inset, edgecolor='red', alpha=0.5, linewidth=2, linestyle='solid')

# Changing the rectangle styles should not affect the connectors.

indicator.rectangle.set(color='blue', linestyle='dashed', linewidth=42, alpha=0.2)

for conn in indicator.connectors:

assert mcolors.same_color(conn.get_edgecolor()[:3], 'red')

assert conn.get_alpha() == 0.5

assert conn.get_linestyle() == 'solid'

assert conn.get_linewidth() == 2

# Changing the indicator styles should affect both rectangle and connectors.

indicator.set(color='green', linestyle='dotted', linewidth=7, alpha=0.8)

assert mcolors.same_color(indicator.rectangle.get_facecolor()[:3], 'green')

for patch in (*indicator.connectors, indicator.rectangle):

assert mcolors.same_color(patch.get_edgecolor()[:3], 'green')

assert patch.get_alpha() == 0.8

assert patch.get_linestyle() == 'dotted'

assert patch.get_linewidth() == 7

indicator.set_edgecolor('purple')

for patch in (*indicator.connectors, indicator.rectangle):

assert mcolors.same_color(patch.get_edgecolor()[:3], 'purple')

# This should also be true if connectors weren't created yet.

indicator._connectors = []

indicator.set(color='burlywood', linestyle='dashdot', linewidth=4, alpha=0.4)

assert mcolors.same_color(indicator.rectangle.get_facecolor()[:3], 'burlywood')

for patch in (*indicator.connectors, indicator.rectangle):

assert mcolors.same_color(patch.get_edgecolor()[:3], 'burlywood')

assert patch.get_alpha() == 0.4

assert patch.get_linestyle() == 'dashdot'

assert patch.get_linewidth() == 4

indicator._connectors = []

indicator.set_edgecolor('thistle')

for patch in (*indicator.connectors, indicator.rectangle):

assert mcolors.same_color(patch.get_edgecolor()[:3], 'thistle')

def test_inset_indicator_zorder():

fig, ax = plt.subplots()

rect = [0.2, 0.2, 0.3, 0.4]

inset = ax.indicate_inset(rect)

assert inset.get_zorder() == 4.99

inset = ax.indicate_inset(rect, zorder=42)

assert inset.get_zorder() == 42

@image_comparison(['zoom_inset_connector_styles.png'], remove_text=True, style='mpl20',

tol=0.024 if platform.machine() == 'arm64' else 0)

def test_zoom_inset_connector_styles():

fig, axs = plt.subplots(2)

for ax in axs:

ax.plot([1, 2, 3])

axs[1].set_xlim(0.5, 1.5)

indicator = axs[0].indicate_inset_zoom(axs[1], linewidth=5)

# Make one visible connector a different style

indicator.connectors[1].set_linestyle('dashed')

indicator.connectors[1].set_color('blue')

@image_comparison(['zoom_inset_transform.png'], remove_text=True, style='mpl20',

tol=0.01)

def test_zoom_inset_transform():

fig, ax = plt.subplots()

ax_ins = ax.inset_axes([0.2, 0.2, 0.3, 0.15])

ax_ins.set_ylim([0.3, 0.6])

ax_ins.set_xlim([0.5, 0.9])

tr = mtransforms.Affine2D().rotate_deg(30)

indicator = ax.indicate_inset_zoom(ax_ins, transform=tr + ax.transData)

for conn in indicator.connectors:

conn.set_visible(True)

def test_zoom_inset_external_transform():

# Smoke test that an external transform that requires an axes (i.e.

# Cartopy) will work.

class FussyDataTr:

def _as_mpl_transform(self, axes=None):

if axes is None:

raise ValueError("I am a fussy transform that requires an axes")

return axes.transData

fig, ax = plt.subplots()

ax_ins = ax.inset_axes([0.2, 0.2, 0.3, 0.15])

ax_ins.set_xlim([0.7, 0.8])

ax_ins.set_ylim([0.7, 0.8])

ax.indicate_inset_zoom(ax_ins, transform=FussyDataTr())

fig.draw_without_rendering()