diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__init__.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c55302485e3fd570f55a255314318c274adc9098
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__init__.py
@@ -0,0 +1,10 @@
+from . import axes_size as Size
+from .axes_divider import Divider, SubplotDivider, make_axes_locatable
+from .axes_grid import AxesGrid, Grid, ImageGrid
+
+from .parasite_axes import host_subplot, host_axes
+
+__all__ = ["Size",
+           "Divider", "SubplotDivider", "make_axes_locatable",
+           "AxesGrid", "Grid", "ImageGrid",
+           "host_subplot", "host_axes"]
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4573afac21ddb3d5e2339a204fe0df9c886340f9
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/anchored_artists.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/anchored_artists.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c47dd4ada8b59479006b1fbc61f8c9d69ea76ef1
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/anchored_artists.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_divider.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_divider.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a63d51e6d9bdc8e8cb2a5052fd8472cb5b7e19c
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_divider.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_grid.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_grid.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d15abdd77ae32edf48a64f7c12b4be189dc3ebf
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_grid.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_rgb.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_rgb.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d3ce9aee726a1d6bb866ff2bdb7906e7aaffaa2
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_rgb.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_size.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_size.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce14d5634e3a494d7a9b0cbd691d7bfe6826022
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/axes_size.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/inset_locator.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/inset_locator.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d09e7745f24b10499311f5bb0cbcbec360f2fcb7
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/inset_locator.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/mpl_axes.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/mpl_axes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2416fcbb082e151b248a95880b208d7d45e9c4c
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/mpl_axes.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/parasite_axes.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/parasite_axes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ec82aafb7890201afb3ec5240aad60fb47bcdfa
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/__pycache__/parasite_axes.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/anchored_artists.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/anchored_artists.py
new file mode 100644
index 0000000000000000000000000000000000000000..1238310b462bc65cc90f861d1034beb4bf0f1fd3
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/anchored_artists.py
@@ -0,0 +1,462 @@
+from matplotlib import _api, transforms
+from matplotlib.offsetbox import (AnchoredOffsetbox, AuxTransformBox,
+                                  DrawingArea, TextArea, VPacker)
+from matplotlib.patches import (Rectangle, Ellipse, ArrowStyle,
+                                FancyArrowPatch, PathPatch)
+from matplotlib.text import TextPath
+
+__all__ = ['AnchoredDrawingArea', 'AnchoredAuxTransformBox',
+           'AnchoredEllipse', 'AnchoredSizeBar', 'AnchoredDirectionArrows']
+
+
+class AnchoredDrawingArea(AnchoredOffsetbox):
+    def __init__(self, width, height, xdescent, ydescent,
+                 loc, pad=0.4, borderpad=0.5, prop=None, frameon=True,
+                 **kwargs):
+        """
+        An anchored container with a fixed size and fillable `.DrawingArea`.
+
+        Artists added to the *drawing_area* will have their coordinates
+        interpreted as pixels. Any transformations set on the artists will be
+        overridden.
+
+        Parameters
+        ----------
+        width, height : float
+            Width and height of the container, in pixels.
+        xdescent, ydescent : float
+            Descent of the container in the x- and y- direction, in pixels.
+        loc : str
+            Location of this artist.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        pad : float, default: 0.4
+            Padding around the child objects, in fraction of the font size.
+        borderpad : float, default: 0.5
+            Border padding, in fraction of the font size.
+        prop : `~matplotlib.font_manager.FontProperties`, optional
+            Font property used as a reference for paddings.
+        frameon : bool, default: True
+            If True, draw a box around this artist.
+        **kwargs
+            Keyword arguments forwarded to `.AnchoredOffsetbox`.
+
+        Attributes
+        ----------
+        drawing_area : `~matplotlib.offsetbox.DrawingArea`
+            A container for artists to display.
+
+        Examples
+        --------
+        To display blue and red circles of different sizes in the upper right
+        of an Axes *ax*:
+
+        >>> ada = AnchoredDrawingArea(20, 20, 0, 0,
+        ...                           loc='upper right', frameon=False)
+        >>> ada.drawing_area.add_artist(Circle((10, 10), 10, fc="b"))
+        >>> ada.drawing_area.add_artist(Circle((30, 10), 5, fc="r"))
+        >>> ax.add_artist(ada)
+        """
+        self.da = DrawingArea(width, height, xdescent, ydescent)
+        self.drawing_area = self.da
+
+        super().__init__(
+            loc, pad=pad, borderpad=borderpad, child=self.da, prop=None,
+            frameon=frameon, **kwargs
+        )
+
+
+class AnchoredAuxTransformBox(AnchoredOffsetbox):
+    def __init__(self, transform, loc,
+                 pad=0.4, borderpad=0.5, prop=None, frameon=True, **kwargs):
+        """
+        An anchored container with transformed coordinates.
+
+        Artists added to the *drawing_area* are scaled according to the
+        coordinates of the transformation used. The dimensions of this artist
+        will scale to contain the artists added.
+
+        Parameters
+        ----------
+        transform : `~matplotlib.transforms.Transform`
+            The transformation object for the coordinate system in use, i.e.,
+            :attr:`matplotlib.axes.Axes.transData`.
+        loc : str
+            Location of this artist.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        pad : float, default: 0.4
+            Padding around the child objects, in fraction of the font size.
+        borderpad : float, default: 0.5
+            Border padding, in fraction of the font size.
+        prop : `~matplotlib.font_manager.FontProperties`, optional
+            Font property used as a reference for paddings.
+        frameon : bool, default: True
+            If True, draw a box around this artist.
+        **kwargs
+            Keyword arguments forwarded to `.AnchoredOffsetbox`.
+
+        Attributes
+        ----------
+        drawing_area : `~matplotlib.offsetbox.AuxTransformBox`
+            A container for artists to display.
+
+        Examples
+        --------
+        To display an ellipse in the upper left, with a width of 0.1 and
+        height of 0.4 in data coordinates:
+
+        >>> box = AnchoredAuxTransformBox(ax.transData, loc='upper left')
+        >>> el = Ellipse((0, 0), width=0.1, height=0.4, angle=30)
+        >>> box.drawing_area.add_artist(el)
+        >>> ax.add_artist(box)
+        """
+        self.drawing_area = AuxTransformBox(transform)
+
+        super().__init__(loc, pad=pad, borderpad=borderpad,
+                         child=self.drawing_area, prop=prop, frameon=frameon,
+                         **kwargs)
+
+
+@_api.deprecated("3.8")
+class AnchoredEllipse(AnchoredOffsetbox):
+    def __init__(self, transform, width, height, angle, loc,
+                 pad=0.1, borderpad=0.1, prop=None, frameon=True, **kwargs):
+        """
+        Draw an anchored ellipse of a given size.
+
+        Parameters
+        ----------
+        transform : `~matplotlib.transforms.Transform`
+            The transformation object for the coordinate system in use, i.e.,
+            :attr:`matplotlib.axes.Axes.transData`.
+        width, height : float
+            Width and height of the ellipse, given in coordinates of
+            *transform*.
+        angle : float
+            Rotation of the ellipse, in degrees, anti-clockwise.
+        loc : str
+            Location of the ellipse.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        pad : float, default: 0.1
+            Padding around the ellipse, in fraction of the font size.
+        borderpad : float, default: 0.1
+            Border padding, in fraction of the font size.
+        frameon : bool, default: True
+            If True, draw a box around the ellipse.
+        prop : `~matplotlib.font_manager.FontProperties`, optional
+            Font property used as a reference for paddings.
+        **kwargs
+            Keyword arguments forwarded to `.AnchoredOffsetbox`.
+
+        Attributes
+        ----------
+        ellipse : `~matplotlib.patches.Ellipse`
+            Ellipse patch drawn.
+        """
+        self._box = AuxTransformBox(transform)
+        self.ellipse = Ellipse((0, 0), width, height, angle=angle)
+        self._box.add_artist(self.ellipse)
+
+        super().__init__(loc, pad=pad, borderpad=borderpad, child=self._box,
+                         prop=prop, frameon=frameon, **kwargs)
+
+
+class AnchoredSizeBar(AnchoredOffsetbox):
+    def __init__(self, transform, size, label, loc,
+                 pad=0.1, borderpad=0.1, sep=2,
+                 frameon=True, size_vertical=0, color='black',
+                 label_top=False, fontproperties=None, fill_bar=None,
+                 **kwargs):
+        """
+        Draw a horizontal scale bar with a center-aligned label underneath.
+
+        Parameters
+        ----------
+        transform : `~matplotlib.transforms.Transform`
+            The transformation object for the coordinate system in use, i.e.,
+            :attr:`matplotlib.axes.Axes.transData`.
+        size : float
+            Horizontal length of the size bar, given in coordinates of
+            *transform*.
+        label : str
+            Label to display.
+        loc : str
+            Location of the size bar.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        pad : float, default: 0.1
+            Padding around the label and size bar, in fraction of the font
+            size.
+        borderpad : float, default: 0.1
+            Border padding, in fraction of the font size.
+        sep : float, default: 2
+            Separation between the label and the size bar, in points.
+        frameon : bool, default: True
+            If True, draw a box around the horizontal bar and label.
+        size_vertical : float, default: 0
+            Vertical length of the size bar, given in coordinates of
+            *transform*.
+        color : str, default: 'black'
+            Color for the size bar and label.
+        label_top : bool, default: False
+            If True, the label will be over the size bar.
+        fontproperties : `~matplotlib.font_manager.FontProperties`, optional
+            Font properties for the label text.
+        fill_bar : bool, optional
+            If True and if *size_vertical* is nonzero, the size bar will
+            be filled in with the color specified by the size bar.
+            Defaults to True if *size_vertical* is greater than
+            zero and False otherwise.
+        **kwargs
+            Keyword arguments forwarded to `.AnchoredOffsetbox`.
+
+        Attributes
+        ----------
+        size_bar : `~matplotlib.offsetbox.AuxTransformBox`
+            Container for the size bar.
+        txt_label : `~matplotlib.offsetbox.TextArea`
+            Container for the label of the size bar.
+
+        Notes
+        -----
+        If *prop* is passed as a keyword argument, but *fontproperties* is
+        not, then *prop* is assumed to be the intended *fontproperties*.
+        Using both *prop* and *fontproperties* is not supported.
+
+        Examples
+        --------
+        >>> import matplotlib.pyplot as plt
+        >>> import numpy as np
+        >>> from mpl_toolkits.axes_grid1.anchored_artists import (
+        ...     AnchoredSizeBar)
+        >>> fig, ax = plt.subplots()
+        >>> ax.imshow(np.random.random((10, 10)))
+        >>> bar = AnchoredSizeBar(ax.transData, 3, '3 data units', 4)
+        >>> ax.add_artist(bar)
+        >>> fig.show()
+
+        Using all the optional parameters
+
+        >>> import matplotlib.font_manager as fm
+        >>> fontprops = fm.FontProperties(size=14, family='monospace')
+        >>> bar = AnchoredSizeBar(ax.transData, 3, '3 units', 4, pad=0.5,
+        ...                       sep=5, borderpad=0.5, frameon=False,
+        ...                       size_vertical=0.5, color='white',
+        ...                       fontproperties=fontprops)
+        """
+        if fill_bar is None:
+            fill_bar = size_vertical > 0
+
+        self.size_bar = AuxTransformBox(transform)
+        self.size_bar.add_artist(Rectangle((0, 0), size, size_vertical,
+                                           fill=fill_bar, facecolor=color,
+                                           edgecolor=color))
+
+        if fontproperties is None and 'prop' in kwargs:
+            fontproperties = kwargs.pop('prop')
+
+        if fontproperties is None:
+            textprops = {'color': color}
+        else:
+            textprops = {'color': color, 'fontproperties': fontproperties}
+
+        self.txt_label = TextArea(label, textprops=textprops)
+
+        if label_top:
+            _box_children = [self.txt_label, self.size_bar]
+        else:
+            _box_children = [self.size_bar, self.txt_label]
+
+        self._box = VPacker(children=_box_children,
+                            align="center",
+                            pad=0, sep=sep)
+
+        super().__init__(loc, pad=pad, borderpad=borderpad, child=self._box,
+                         prop=fontproperties, frameon=frameon, **kwargs)
+
+
+class AnchoredDirectionArrows(AnchoredOffsetbox):
+    def __init__(self, transform, label_x, label_y, length=0.15,
+                 fontsize=0.08, loc='upper left', angle=0, aspect_ratio=1,
+                 pad=0.4, borderpad=0.4, frameon=False, color='w', alpha=1,
+                 sep_x=0.01, sep_y=0, fontproperties=None, back_length=0.15,
+                 head_width=10, head_length=15, tail_width=2,
+                 text_props=None, arrow_props=None,
+                 **kwargs):
+        """
+        Draw two perpendicular arrows to indicate directions.
+
+        Parameters
+        ----------
+        transform : `~matplotlib.transforms.Transform`
+            The transformation object for the coordinate system in use, i.e.,
+            :attr:`matplotlib.axes.Axes.transAxes`.
+        label_x, label_y : str
+            Label text for the x and y arrows
+        length : float, default: 0.15
+            Length of the arrow, given in coordinates of *transform*.
+        fontsize : float, default: 0.08
+            Size of label strings, given in coordinates of *transform*.
+        loc : str, default: 'upper left'
+            Location of the arrow.  Valid locations are
+            'upper left', 'upper center', 'upper right',
+            'center left', 'center', 'center right',
+            'lower left', 'lower center', 'lower right'.
+            For backward compatibility, numeric values are accepted as well.
+            See the parameter *loc* of `.Legend` for details.
+        angle : float, default: 0
+            The angle of the arrows in degrees.
+        aspect_ratio : float, default: 1
+            The ratio of the length of arrow_x and arrow_y.
+            Negative numbers can be used to change the direction.
+        pad : float, default: 0.4
+            Padding around the labels and arrows, in fraction of the font size.
+        borderpad : float, default: 0.4
+            Border padding, in fraction of the font size.
+        frameon : bool, default: False
+            If True, draw a box around the arrows and labels.
+        color : str, default: 'white'
+            Color for the arrows and labels.
+        alpha : float, default: 1
+            Alpha values of the arrows and labels
+        sep_x, sep_y : float, default: 0.01 and 0 respectively
+            Separation between the arrows and labels in coordinates of
+            *transform*.
+        fontproperties : `~matplotlib.font_manager.FontProperties`, optional
+            Font properties for the label text.
+        back_length : float, default: 0.15
+            Fraction of the arrow behind the arrow crossing.
+        head_width : float, default: 10
+            Width of arrow head, sent to `.ArrowStyle`.
+        head_length : float, default: 15
+            Length of arrow head, sent to `.ArrowStyle`.
+        tail_width : float, default: 2
+            Width of arrow tail, sent to `.ArrowStyle`.
+        text_props, arrow_props : dict
+            Properties of the text and arrows, passed to `.TextPath` and
+            `.FancyArrowPatch`.
+        **kwargs
+            Keyword arguments forwarded to `.AnchoredOffsetbox`.
+
+        Attributes
+        ----------
+        arrow_x, arrow_y : `~matplotlib.patches.FancyArrowPatch`
+            Arrow x and y
+        text_path_x, text_path_y : `~matplotlib.text.TextPath`
+            Path for arrow labels
+        p_x, p_y : `~matplotlib.patches.PathPatch`
+            Patch for arrow labels
+        box : `~matplotlib.offsetbox.AuxTransformBox`
+            Container for the arrows and labels.
+
+        Notes
+        -----
+        If *prop* is passed as a keyword argument, but *fontproperties* is
+        not, then *prop* is assumed to be the intended *fontproperties*.
+        Using both *prop* and *fontproperties* is not supported.
+
+        Examples
+        --------
+        >>> import matplotlib.pyplot as plt
+        >>> import numpy as np
+        >>> from mpl_toolkits.axes_grid1.anchored_artists import (
+        ...     AnchoredDirectionArrows)
+        >>> fig, ax = plt.subplots()
+        >>> ax.imshow(np.random.random((10, 10)))
+        >>> arrows = AnchoredDirectionArrows(ax.transAxes, '111', '110')
+        >>> ax.add_artist(arrows)
+        >>> fig.show()
+
+        Using several of the optional parameters, creating downward pointing
+        arrow and high contrast text labels.
+
+        >>> import matplotlib.font_manager as fm
+        >>> fontprops = fm.FontProperties(family='monospace')
+        >>> arrows = AnchoredDirectionArrows(ax.transAxes, 'East', 'South',
+        ...                                  loc='lower left', color='k',
+        ...                                  aspect_ratio=-1, sep_x=0.02,
+        ...                                  sep_y=-0.01,
+        ...                                  text_props={'ec':'w', 'fc':'k'},
+        ...                                  fontproperties=fontprops)
+        """
+        if arrow_props is None:
+            arrow_props = {}
+
+        if text_props is None:
+            text_props = {}
+
+        arrowstyle = ArrowStyle("Simple",
+                                head_width=head_width,
+                                head_length=head_length,
+                                tail_width=tail_width)
+
+        if fontproperties is None and 'prop' in kwargs:
+            fontproperties = kwargs.pop('prop')
+
+        if 'color' not in arrow_props:
+            arrow_props['color'] = color
+
+        if 'alpha' not in arrow_props:
+            arrow_props['alpha'] = alpha
+
+        if 'color' not in text_props:
+            text_props['color'] = color
+
+        if 'alpha' not in text_props:
+            text_props['alpha'] = alpha
+
+        t_start = transform
+        t_end = t_start + transforms.Affine2D().rotate_deg(angle)
+
+        self.box = AuxTransformBox(t_end)
+
+        length_x = length
+        length_y = length*aspect_ratio
+
+        self.arrow_x = FancyArrowPatch(
+                (0, back_length*length_y),
+                (length_x, back_length*length_y),
+                arrowstyle=arrowstyle,
+                shrinkA=0.0,
+                shrinkB=0.0,
+                **arrow_props)
+
+        self.arrow_y = FancyArrowPatch(
+                (back_length*length_x, 0),
+                (back_length*length_x, length_y),
+                arrowstyle=arrowstyle,
+                shrinkA=0.0,
+                shrinkB=0.0,
+                **arrow_props)
+
+        self.box.add_artist(self.arrow_x)
+        self.box.add_artist(self.arrow_y)
+
+        text_path_x = TextPath((
+            length_x+sep_x, back_length*length_y+sep_y), label_x,
+            size=fontsize, prop=fontproperties)
+        self.p_x = PathPatch(text_path_x, transform=t_start, **text_props)
+        self.box.add_artist(self.p_x)
+
+        text_path_y = TextPath((
+            length_x*back_length+sep_x, length_y*(1-back_length)+sep_y),
+            label_y, size=fontsize, prop=fontproperties)
+        self.p_y = PathPatch(text_path_y, **text_props)
+        self.box.add_artist(self.p_y)
+
+        super().__init__(loc, pad=pad, borderpad=borderpad, child=self.box,
+                         frameon=frameon, **kwargs)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_divider.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_divider.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6c38f35dbc4a5835589cb559531d9fe0509c126
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_divider.py
@@ -0,0 +1,694 @@
+"""
+Helper classes to adjust the positions of multiple axes at drawing time.
+"""
+
+import functools
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api
+from matplotlib.gridspec import SubplotSpec
+import matplotlib.transforms as mtransforms
+from . import axes_size as Size
+
+
+class Divider:
+    """
+    An Axes positioning class.
+
+    The divider is initialized with lists of horizontal and vertical sizes
+    (:mod:`mpl_toolkits.axes_grid1.axes_size`) based on which a given
+    rectangular area will be divided.
+
+    The `new_locator` method then creates a callable object
+    that can be used as the *axes_locator* of the axes.
+    """
+
+    def __init__(self, fig, pos, horizontal, vertical,
+                 aspect=None, anchor="C"):
+        """
+        Parameters
+        ----------
+        fig : Figure
+        pos : tuple of 4 floats
+            Position of the rectangle that will be divided.
+        horizontal : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`
+            Sizes for horizontal division.
+        vertical : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`
+            Sizes for vertical division.
+        aspect : bool, optional
+            Whether overall rectangular area is reduced so that the relative
+            part of the horizontal and vertical scales have the same scale.
+        anchor : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', 'N', \
+'NW', 'W'}, default: 'C'
+            Placement of the reduced rectangle, when *aspect* is True.
+        """
+
+        self._fig = fig
+        self._pos = pos
+        self._horizontal = horizontal
+        self._vertical = vertical
+        self._anchor = anchor
+        self.set_anchor(anchor)
+        self._aspect = aspect
+        self._xrefindex = 0
+        self._yrefindex = 0
+        self._locator = None
+
+    def get_horizontal_sizes(self, renderer):
+        return np.array([s.get_size(renderer) for s in self.get_horizontal()])
+
+    def get_vertical_sizes(self, renderer):
+        return np.array([s.get_size(renderer) for s in self.get_vertical()])
+
+    def set_position(self, pos):
+        """
+        Set the position of the rectangle.
+
+        Parameters
+        ----------
+        pos : tuple of 4 floats
+            position of the rectangle that will be divided
+        """
+        self._pos = pos
+
+    def get_position(self):
+        """Return the position of the rectangle."""
+        return self._pos
+
+    def set_anchor(self, anchor):
+        """
+        Parameters
+        ----------
+        anchor : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', 'N', \
+'NW', 'W'}
+            Either an (*x*, *y*) pair of relative coordinates (0 is left or
+            bottom, 1 is right or top), 'C' (center), or a cardinal direction
+            ('SW', southwest, is bottom left, etc.).
+
+        See Also
+        --------
+        .Axes.set_anchor
+        """
+        if isinstance(anchor, str):
+            _api.check_in_list(mtransforms.Bbox.coefs, anchor=anchor)
+        elif not isinstance(anchor, (tuple, list)) or len(anchor) != 2:
+            raise TypeError("anchor must be str or 2-tuple")
+        self._anchor = anchor
+
+    def get_anchor(self):
+        """Return the anchor."""
+        return self._anchor
+
+    def get_subplotspec(self):
+        return None
+
+    def set_horizontal(self, h):
+        """
+        Parameters
+        ----------
+        h : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`
+            sizes for horizontal division
+        """
+        self._horizontal = h
+
+    def get_horizontal(self):
+        """Return horizontal sizes."""
+        return self._horizontal
+
+    def set_vertical(self, v):
+        """
+        Parameters
+        ----------
+        v : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`
+            sizes for vertical division
+        """
+        self._vertical = v
+
+    def get_vertical(self):
+        """Return vertical sizes."""
+        return self._vertical
+
+    def set_aspect(self, aspect=False):
+        """
+        Parameters
+        ----------
+        aspect : bool
+        """
+        self._aspect = aspect
+
+    def get_aspect(self):
+        """Return aspect."""
+        return self._aspect
+
+    def set_locator(self, _locator):
+        self._locator = _locator
+
+    def get_locator(self):
+        return self._locator
+
+    def get_position_runtime(self, ax, renderer):
+        if self._locator is None:
+            return self.get_position()
+        else:
+            return self._locator(ax, renderer).bounds
+
+    @staticmethod
+    def _calc_k(sizes, total):
+        # sizes is a (n, 2) array of (rel_size, abs_size); this method finds
+        # the k factor such that sum(rel_size * k + abs_size) == total.
+        rel_sum, abs_sum = sizes.sum(0)
+        return (total - abs_sum) / rel_sum if rel_sum else 0
+
+    @staticmethod
+    def _calc_offsets(sizes, k):
+        # Apply k factors to (n, 2) sizes array of (rel_size, abs_size); return
+        # the resulting cumulative offset positions.
+        return np.cumsum([0, *(sizes @ [k, 1])])
+
+    def new_locator(self, nx, ny, nx1=None, ny1=None):
+        """
+        Return an axes locator callable for the specified cell.
+
+        Parameters
+        ----------
+        nx, nx1 : int
+            Integers specifying the column-position of the
+            cell. When *nx1* is None, a single *nx*-th column is
+            specified. Otherwise, location of columns spanning between *nx*
+            to *nx1* (but excluding *nx1*-th column) is specified.
+        ny, ny1 : int
+            Same as *nx* and *nx1*, but for row positions.
+        """
+        if nx1 is None:
+            nx1 = nx + 1
+        if ny1 is None:
+            ny1 = ny + 1
+        # append_size("left") adds a new size at the beginning of the
+        # horizontal size lists; this shift transforms e.g.
+        # new_locator(nx=2, ...) into effectively new_locator(nx=3, ...).  To
+        # take that into account, instead of recording nx, we record
+        # nx-self._xrefindex, where _xrefindex is shifted by 1 by each
+        # append_size("left"), and re-add self._xrefindex back to nx in
+        # _locate, when the actual axes position is computed.  Ditto for y.
+        xref = self._xrefindex
+        yref = self._yrefindex
+        locator = functools.partial(
+            self._locate, nx - xref, ny - yref, nx1 - xref, ny1 - yref)
+        locator.get_subplotspec = self.get_subplotspec
+        return locator
+
+    @_api.deprecated(
+        "3.8", alternative="divider.new_locator(...)(ax, renderer)")
+    def locate(self, nx, ny, nx1=None, ny1=None, axes=None, renderer=None):
+        """
+        Implementation of ``divider.new_locator().__call__``.
+
+        Parameters
+        ----------
+        nx, nx1 : int
+            Integers specifying the column-position of the cell. When *nx1* is
+            None, a single *nx*-th column is specified. Otherwise, the
+            location of columns spanning between *nx* to *nx1* (but excluding
+            *nx1*-th column) is specified.
+        ny, ny1 : int
+            Same as *nx* and *nx1*, but for row positions.
+        axes
+        renderer
+        """
+        xref = self._xrefindex
+        yref = self._yrefindex
+        return self._locate(
+            nx - xref, (nx + 1 if nx1 is None else nx1) - xref,
+            ny - yref, (ny + 1 if ny1 is None else ny1) - yref,
+            axes, renderer)
+
+    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
+        """
+        Implementation of ``divider.new_locator().__call__``.
+
+        The axes locator callable returned by ``new_locator()`` is created as
+        a `functools.partial` of this method with *nx*, *ny*, *nx1*, and *ny1*
+        specifying the requested cell.
+        """
+        nx += self._xrefindex
+        nx1 += self._xrefindex
+        ny += self._yrefindex
+        ny1 += self._yrefindex
+
+        fig_w, fig_h = self._fig.bbox.size / self._fig.dpi
+        x, y, w, h = self.get_position_runtime(axes, renderer)
+
+        hsizes = self.get_horizontal_sizes(renderer)
+        vsizes = self.get_vertical_sizes(renderer)
+        k_h = self._calc_k(hsizes, fig_w * w)
+        k_v = self._calc_k(vsizes, fig_h * h)
+
+        if self.get_aspect():
+            k = min(k_h, k_v)
+            ox = self._calc_offsets(hsizes, k)
+            oy = self._calc_offsets(vsizes, k)
+
+            ww = (ox[-1] - ox[0]) / fig_w
+            hh = (oy[-1] - oy[0]) / fig_h
+            pb = mtransforms.Bbox.from_bounds(x, y, w, h)
+            pb1 = mtransforms.Bbox.from_bounds(x, y, ww, hh)
+            x0, y0 = pb1.anchored(self.get_anchor(), pb).p0
+
+        else:
+            ox = self._calc_offsets(hsizes, k_h)
+            oy = self._calc_offsets(vsizes, k_v)
+            x0, y0 = x, y
+
+        if nx1 is None:
+            nx1 = -1
+        if ny1 is None:
+            ny1 = -1
+
+        x1, w1 = x0 + ox[nx] / fig_w, (ox[nx1] - ox[nx]) / fig_w
+        y1, h1 = y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h
+
+        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)
+
+    def append_size(self, position, size):
+        _api.check_in_list(["left", "right", "bottom", "top"],
+                           position=position)
+        if position == "left":
+            self._horizontal.insert(0, size)
+            self._xrefindex += 1
+        elif position == "right":
+            self._horizontal.append(size)
+        elif position == "bottom":
+            self._vertical.insert(0, size)
+            self._yrefindex += 1
+        else:  # 'top'
+            self._vertical.append(size)
+
+    def add_auto_adjustable_area(self, use_axes, pad=0.1, adjust_dirs=None):
+        """
+        Add auto-adjustable padding around *use_axes* to take their decorations
+        (title, labels, ticks, ticklabels) into account during layout.
+
+        Parameters
+        ----------
+        use_axes : `~matplotlib.axes.Axes` or list of `~matplotlib.axes.Axes`
+            The Axes whose decorations are taken into account.
+        pad : float, default: 0.1
+            Additional padding in inches.
+        adjust_dirs : list of {"left", "right", "bottom", "top"}, optional
+            The sides where padding is added; defaults to all four sides.
+        """
+        if adjust_dirs is None:
+            adjust_dirs = ["left", "right", "bottom", "top"]
+        for d in adjust_dirs:
+            self.append_size(d, Size._AxesDecorationsSize(use_axes, d) + pad)
+
+
+@_api.deprecated("3.8")
+class AxesLocator:
+    """
+    A callable object which returns the position and size of a given
+    `.AxesDivider` cell.
+    """
+
+    def __init__(self, axes_divider, nx, ny, nx1=None, ny1=None):
+        """
+        Parameters
+        ----------
+        axes_divider : `~mpl_toolkits.axes_grid1.axes_divider.AxesDivider`
+        nx, nx1 : int
+            Integers specifying the column-position of the
+            cell. When *nx1* is None, a single *nx*-th column is
+            specified. Otherwise, location of columns spanning between *nx*
+            to *nx1* (but excluding *nx1*-th column) is specified.
+        ny, ny1 : int
+            Same as *nx* and *nx1*, but for row positions.
+        """
+        self._axes_divider = axes_divider
+
+        _xrefindex = axes_divider._xrefindex
+        _yrefindex = axes_divider._yrefindex
+
+        self._nx, self._ny = nx - _xrefindex, ny - _yrefindex
+
+        if nx1 is None:
+            nx1 = len(self._axes_divider)
+        if ny1 is None:
+            ny1 = len(self._axes_divider[0])
+
+        self._nx1 = nx1 - _xrefindex
+        self._ny1 = ny1 - _yrefindex
+
+    def __call__(self, axes, renderer):
+
+        _xrefindex = self._axes_divider._xrefindex
+        _yrefindex = self._axes_divider._yrefindex
+
+        return self._axes_divider.locate(self._nx + _xrefindex,
+                                         self._ny + _yrefindex,
+                                         self._nx1 + _xrefindex,
+                                         self._ny1 + _yrefindex,
+                                         axes,
+                                         renderer)
+
+    def get_subplotspec(self):
+        return self._axes_divider.get_subplotspec()
+
+
+class SubplotDivider(Divider):
+    """
+    The Divider class whose rectangle area is specified as a subplot geometry.
+    """
+
+    def __init__(self, fig, *args, horizontal=None, vertical=None,
+                 aspect=None, anchor='C'):
+        """
+        Parameters
+        ----------
+        fig : `~matplotlib.figure.Figure`
+
+        *args : tuple (*nrows*, *ncols*, *index*) or int
+            The array of subplots in the figure has dimensions ``(nrows,
+            ncols)``, and *index* is the index of the subplot being created.
+            *index* starts at 1 in the upper left corner and increases to the
+            right.
+
+            If *nrows*, *ncols*, and *index* are all single digit numbers, then
+            *args* can be passed as a single 3-digit number (e.g. 234 for
+            (2, 3, 4)).
+        horizontal : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`, optional
+            Sizes for horizontal division.
+        vertical : list of :mod:`~mpl_toolkits.axes_grid1.axes_size`, optional
+            Sizes for vertical division.
+        aspect : bool, optional
+            Whether overall rectangular area is reduced so that the relative
+            part of the horizontal and vertical scales have the same scale.
+        anchor : (float, float) or {'C', 'SW', 'S', 'SE', 'E', 'NE', 'N', \
+'NW', 'W'}, default: 'C'
+            Placement of the reduced rectangle, when *aspect* is True.
+        """
+        self.figure = fig
+        super().__init__(fig, [0, 0, 1, 1],
+                         horizontal=horizontal or [], vertical=vertical or [],
+                         aspect=aspect, anchor=anchor)
+        self.set_subplotspec(SubplotSpec._from_subplot_args(fig, args))
+
+    def get_position(self):
+        """Return the bounds of the subplot box."""
+        return self.get_subplotspec().get_position(self.figure).bounds
+
+    def get_subplotspec(self):
+        """Get the SubplotSpec instance."""
+        return self._subplotspec
+
+    def set_subplotspec(self, subplotspec):
+        """Set the SubplotSpec instance."""
+        self._subplotspec = subplotspec
+        self.set_position(subplotspec.get_position(self.figure))
+
+
+class AxesDivider(Divider):
+    """
+    Divider based on the preexisting axes.
+    """
+
+    def __init__(self, axes, xref=None, yref=None):
+        """
+        Parameters
+        ----------
+        axes : :class:`~matplotlib.axes.Axes`
+        xref
+        yref
+        """
+        self._axes = axes
+        if xref is None:
+            self._xref = Size.AxesX(axes)
+        else:
+            self._xref = xref
+        if yref is None:
+            self._yref = Size.AxesY(axes)
+        else:
+            self._yref = yref
+
+        super().__init__(fig=axes.get_figure(), pos=None,
+                         horizontal=[self._xref], vertical=[self._yref],
+                         aspect=None, anchor="C")
+
+    def _get_new_axes(self, *, axes_class=None, **kwargs):
+        axes = self._axes
+        if axes_class is None:
+            axes_class = type(axes)
+        return axes_class(axes.get_figure(), axes.get_position(original=True),
+                          **kwargs)
+
+    def new_horizontal(self, size, pad=None, pack_start=False, **kwargs):
+        """
+        Helper method for ``append_axes("left")`` and ``append_axes("right")``.
+
+        See the documentation of `append_axes` for more details.
+
+        :meta private:
+        """
+        if pad is None:
+            pad = mpl.rcParams["figure.subplot.wspace"] * self._xref
+        pos = "left" if pack_start else "right"
+        if pad:
+            if not isinstance(pad, Size._Base):
+                pad = Size.from_any(pad, fraction_ref=self._xref)
+            self.append_size(pos, pad)
+        if not isinstance(size, Size._Base):
+            size = Size.from_any(size, fraction_ref=self._xref)
+        self.append_size(pos, size)
+        locator = self.new_locator(
+            nx=0 if pack_start else len(self._horizontal) - 1,
+            ny=self._yrefindex)
+        ax = self._get_new_axes(**kwargs)
+        ax.set_axes_locator(locator)
+        return ax
+
+    def new_vertical(self, size, pad=None, pack_start=False, **kwargs):
+        """
+        Helper method for ``append_axes("top")`` and ``append_axes("bottom")``.
+
+        See the documentation of `append_axes` for more details.
+
+        :meta private:
+        """
+        if pad is None:
+            pad = mpl.rcParams["figure.subplot.hspace"] * self._yref
+        pos = "bottom" if pack_start else "top"
+        if pad:
+            if not isinstance(pad, Size._Base):
+                pad = Size.from_any(pad, fraction_ref=self._yref)
+            self.append_size(pos, pad)
+        if not isinstance(size, Size._Base):
+            size = Size.from_any(size, fraction_ref=self._yref)
+        self.append_size(pos, size)
+        locator = self.new_locator(
+            nx=self._xrefindex,
+            ny=0 if pack_start else len(self._vertical) - 1)
+        ax = self._get_new_axes(**kwargs)
+        ax.set_axes_locator(locator)
+        return ax
+
+    def append_axes(self, position, size, pad=None, *, axes_class=None,
+                    **kwargs):
+        """
+        Add a new axes on a given side of the main axes.
+
+        Parameters
+        ----------
+        position : {"left", "right", "bottom", "top"}
+            Where the new axes is positioned relative to the main axes.
+        size : :mod:`~mpl_toolkits.axes_grid1.axes_size` or float or str
+            The axes width or height.  float or str arguments are interpreted
+            as ``axes_size.from_any(size, AxesX(<main_axes>))`` for left or
+            right axes, and likewise with ``AxesY`` for bottom or top axes.
+        pad : :mod:`~mpl_toolkits.axes_grid1.axes_size` or float or str
+            Padding between the axes.  float or str arguments are interpreted
+            as for *size*.  Defaults to :rc:`figure.subplot.wspace` times the
+            main Axes width (left or right axes) or :rc:`figure.subplot.hspace`
+            times the main Axes height (bottom or top axes).
+        axes_class : subclass type of `~.axes.Axes`, optional
+            The type of the new axes.  Defaults to the type of the main axes.
+        **kwargs
+            All extra keywords arguments are passed to the created axes.
+        """
+        create_axes, pack_start = _api.check_getitem({
+            "left": (self.new_horizontal, True),
+            "right": (self.new_horizontal, False),
+            "bottom": (self.new_vertical, True),
+            "top": (self.new_vertical, False),
+        }, position=position)
+        ax = create_axes(
+            size, pad, pack_start=pack_start, axes_class=axes_class, **kwargs)
+        self._fig.add_axes(ax)
+        return ax
+
+    def get_aspect(self):
+        if self._aspect is None:
+            aspect = self._axes.get_aspect()
+            if aspect == "auto":
+                return False
+            else:
+                return True
+        else:
+            return self._aspect
+
+    def get_position(self):
+        if self._pos is None:
+            bbox = self._axes.get_position(original=True)
+            return bbox.bounds
+        else:
+            return self._pos
+
+    def get_anchor(self):
+        if self._anchor is None:
+            return self._axes.get_anchor()
+        else:
+            return self._anchor
+
+    def get_subplotspec(self):
+        return self._axes.get_subplotspec()
+
+
+# Helper for HBoxDivider/VBoxDivider.
+# The variable names are written for a horizontal layout, but the calculations
+# work identically for vertical layouts.
+def _locate(x, y, w, h, summed_widths, equal_heights, fig_w, fig_h, anchor):
+
+    total_width = fig_w * w
+    max_height = fig_h * h
+
+    # Determine the k factors.
+    n = len(equal_heights)
+    eq_rels, eq_abss = equal_heights.T
+    sm_rels, sm_abss = summed_widths.T
+    A = np.diag([*eq_rels, 0])
+    A[:n, -1] = -1
+    A[-1, :-1] = sm_rels
+    B = [*(-eq_abss), total_width - sm_abss.sum()]
+    # A @ K = B: This finds factors {k_0, ..., k_{N-1}, H} so that
+    #   eq_rel_i * k_i + eq_abs_i = H for all i: all axes have the same height
+    #   sum(sm_rel_i * k_i + sm_abs_i) = total_width: fixed total width
+    # (foo_rel_i * k_i + foo_abs_i will end up being the size of foo.)
+    *karray, height = np.linalg.solve(A, B)
+    if height > max_height:  # Additionally, upper-bound the height.
+        karray = (max_height - eq_abss) / eq_rels
+
+    # Compute the offsets corresponding to these factors.
+    ox = np.cumsum([0, *(sm_rels * karray + sm_abss)])
+    ww = (ox[-1] - ox[0]) / fig_w
+    h0_rel, h0_abs = equal_heights[0]
+    hh = (karray[0]*h0_rel + h0_abs) / fig_h
+    pb = mtransforms.Bbox.from_bounds(x, y, w, h)
+    pb1 = mtransforms.Bbox.from_bounds(x, y, ww, hh)
+    x0, y0 = pb1.anchored(anchor, pb).p0
+
+    return x0, y0, ox, hh
+
+
+class HBoxDivider(SubplotDivider):
+    """
+    A `.SubplotDivider` for laying out axes horizontally, while ensuring that
+    they have equal heights.
+
+    Examples
+    --------
+    .. plot:: gallery/axes_grid1/demo_axes_hbox_divider.py
+    """
+
+    def new_locator(self, nx, nx1=None):
+        """
+        Create an axes locator callable for the specified cell.
+
+        Parameters
+        ----------
+        nx, nx1 : int
+            Integers specifying the column-position of the
+            cell. When *nx1* is None, a single *nx*-th column is
+            specified. Otherwise, location of columns spanning between *nx*
+            to *nx1* (but excluding *nx1*-th column) is specified.
+        """
+        return super().new_locator(nx, 0, nx1, 0)
+
+    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
+        # docstring inherited
+        nx += self._xrefindex
+        nx1 += self._xrefindex
+        fig_w, fig_h = self._fig.bbox.size / self._fig.dpi
+        x, y, w, h = self.get_position_runtime(axes, renderer)
+        summed_ws = self.get_horizontal_sizes(renderer)
+        equal_hs = self.get_vertical_sizes(renderer)
+        x0, y0, ox, hh = _locate(
+            x, y, w, h, summed_ws, equal_hs, fig_w, fig_h, self.get_anchor())
+        if nx1 is None:
+            nx1 = -1
+        x1, w1 = x0 + ox[nx] / fig_w, (ox[nx1] - ox[nx]) / fig_w
+        y1, h1 = y0, hh
+        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)
+
+
+class VBoxDivider(SubplotDivider):
+    """
+    A `.SubplotDivider` for laying out axes vertically, while ensuring that
+    they have equal widths.
+    """
+
+    def new_locator(self, ny, ny1=None):
+        """
+        Create an axes locator callable for the specified cell.
+
+        Parameters
+        ----------
+        ny, ny1 : int
+            Integers specifying the row-position of the
+            cell. When *ny1* is None, a single *ny*-th row is
+            specified. Otherwise, location of rows spanning between *ny*
+            to *ny1* (but excluding *ny1*-th row) is specified.
+        """
+        return super().new_locator(0, ny, 0, ny1)
+
+    def _locate(self, nx, ny, nx1, ny1, axes, renderer):
+        # docstring inherited
+        ny += self._yrefindex
+        ny1 += self._yrefindex
+        fig_w, fig_h = self._fig.bbox.size / self._fig.dpi
+        x, y, w, h = self.get_position_runtime(axes, renderer)
+        summed_hs = self.get_vertical_sizes(renderer)
+        equal_ws = self.get_horizontal_sizes(renderer)
+        y0, x0, oy, ww = _locate(
+            y, x, h, w, summed_hs, equal_ws, fig_h, fig_w, self.get_anchor())
+        if ny1 is None:
+            ny1 = -1
+        x1, w1 = x0, ww
+        y1, h1 = y0 + oy[ny] / fig_h, (oy[ny1] - oy[ny]) / fig_h
+        return mtransforms.Bbox.from_bounds(x1, y1, w1, h1)
+
+
+def make_axes_locatable(axes):
+    divider = AxesDivider(axes)
+    locator = divider.new_locator(nx=0, ny=0)
+    axes.set_axes_locator(locator)
+
+    return divider
+
+
+def make_axes_area_auto_adjustable(
+        ax, use_axes=None, pad=0.1, adjust_dirs=None):
+    """
+    Add auto-adjustable padding around *ax* to take its decorations (title,
+    labels, ticks, ticklabels) into account during layout, using
+    `.Divider.add_auto_adjustable_area`.
+
+    By default, padding is determined from the decorations of *ax*.
+    Pass *use_axes* to consider the decorations of other Axes instead.
+    """
+    if adjust_dirs is None:
+        adjust_dirs = ["left", "right", "bottom", "top"]
+    divider = make_axes_locatable(ax)
+    if use_axes is None:
+        use_axes = ax
+    divider.add_auto_adjustable_area(use_axes=use_axes, pad=pad,
+                                     adjust_dirs=adjust_dirs)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_grid.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_grid.py
new file mode 100644
index 0000000000000000000000000000000000000000..315a7bccd6686d7d515f2cfcf84b79c046674c9c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_grid.py
@@ -0,0 +1,563 @@
+from numbers import Number
+import functools
+from types import MethodType
+
+import numpy as np
+
+from matplotlib import _api, cbook
+from matplotlib.gridspec import SubplotSpec
+
+from .axes_divider import Size, SubplotDivider, Divider
+from .mpl_axes import Axes, SimpleAxisArtist
+
+
+class CbarAxesBase:
+    def __init__(self, *args, orientation, **kwargs):
+        self.orientation = orientation
+        super().__init__(*args, **kwargs)
+
+    def colorbar(self, mappable, **kwargs):
+        return self.figure.colorbar(
+            mappable, cax=self, location=self.orientation, **kwargs)
+
+    @_api.deprecated("3.8", alternative="ax.tick_params and colorbar.set_label")
+    def toggle_label(self, b):
+        axis = self.axis[self.orientation]
+        axis.toggle(ticklabels=b, label=b)
+
+
+_cbaraxes_class_factory = cbook._make_class_factory(CbarAxesBase, "Cbar{}")
+
+
+class Grid:
+    """
+    A grid of Axes.
+
+    In Matplotlib, the Axes location (and size) is specified in normalized
+    figure coordinates. This may not be ideal for images that needs to be
+    displayed with a given aspect ratio; for example, it is difficult to
+    display multiple images of a same size with some fixed padding between
+    them.  AxesGrid can be used in such case.
+
+    Attributes
+    ----------
+    axes_all : list of Axes
+        A flat list of Axes. Note that you can also access this directly
+        from the grid. The following is equivalent ::
+
+            grid[i] == grid.axes_all[i]
+            len(grid) == len(grid.axes_all)
+
+    axes_column : list of list of Axes
+        A 2D list of Axes where the first index is the column. This results
+        in the usage pattern ``grid.axes_column[col][row]``.
+    axes_row : list of list of Axes
+        A 2D list of Axes where the first index is the row. This results
+        in the usage pattern ``grid.axes_row[row][col]``.
+    axes_llc : Axes
+        The Axes in the lower left corner.
+    ngrids : int
+        Number of Axes in the grid.
+    """
+
+    _defaultAxesClass = Axes
+
+    def __init__(self, fig,
+                 rect,
+                 nrows_ncols,
+                 ngrids=None,
+                 direction="row",
+                 axes_pad=0.02,
+                 *,
+                 share_all=False,
+                 share_x=True,
+                 share_y=True,
+                 label_mode="L",
+                 axes_class=None,
+                 aspect=False,
+                 ):
+        """
+        Parameters
+        ----------
+        fig : `.Figure`
+            The parent figure.
+        rect : (float, float, float, float), (int, int, int), int, or \
+    `~.SubplotSpec`
+            The axes position, as a ``(left, bottom, width, height)`` tuple,
+            as a three-digit subplot position code (e.g., ``(1, 2, 1)`` or
+            ``121``), or as a `~.SubplotSpec`.
+        nrows_ncols : (int, int)
+            Number of rows and columns in the grid.
+        ngrids : int or None, default: None
+            If not None, only the first *ngrids* axes in the grid are created.
+        direction : {"row", "column"}, default: "row"
+            Whether axes are created in row-major ("row by row") or
+            column-major order ("column by column").  This also affects the
+            order in which axes are accessed using indexing (``grid[index]``).
+        axes_pad : float or (float, float), default: 0.02
+            Padding or (horizontal padding, vertical padding) between axes, in
+            inches.
+        share_all : bool, default: False
+            Whether all axes share their x- and y-axis.  Overrides *share_x*
+            and *share_y*.
+        share_x : bool, default: True
+            Whether all axes of a column share their x-axis.
+        share_y : bool, default: True
+            Whether all axes of a row share their y-axis.
+        label_mode : {"L", "1", "all", "keep"}, default: "L"
+            Determines which axes will get tick labels:
+
+            - "L": All axes on the left column get vertical tick labels;
+              all axes on the bottom row get horizontal tick labels.
+            - "1": Only the bottom left axes is labelled.
+            - "all": All axes are labelled.
+            - "keep": Do not do anything.
+
+        axes_class : subclass of `matplotlib.axes.Axes`, default: `.mpl_axes.Axes`
+            The type of Axes to create.
+        aspect : bool, default: False
+            Whether the axes aspect ratio follows the aspect ratio of the data
+            limits.
+        """
+        self._nrows, self._ncols = nrows_ncols
+
+        if ngrids is None:
+            ngrids = self._nrows * self._ncols
+        else:
+            if not 0 < ngrids <= self._nrows * self._ncols:
+                raise ValueError(
+                    "ngrids must be positive and not larger than nrows*ncols")
+
+        self.ngrids = ngrids
+
+        self._horiz_pad_size, self._vert_pad_size = map(
+            Size.Fixed, np.broadcast_to(axes_pad, 2))
+
+        _api.check_in_list(["column", "row"], direction=direction)
+        self._direction = direction
+
+        if axes_class is None:
+            axes_class = self._defaultAxesClass
+        elif isinstance(axes_class, (list, tuple)):
+            cls, kwargs = axes_class
+            axes_class = functools.partial(cls, **kwargs)
+
+        kw = dict(horizontal=[], vertical=[], aspect=aspect)
+        if isinstance(rect, (Number, SubplotSpec)):
+            self._divider = SubplotDivider(fig, rect, **kw)
+        elif len(rect) == 3:
+            self._divider = SubplotDivider(fig, *rect, **kw)
+        elif len(rect) == 4:
+            self._divider = Divider(fig, rect, **kw)
+        else:
+            raise TypeError("Incorrect rect format")
+
+        rect = self._divider.get_position()
+
+        axes_array = np.full((self._nrows, self._ncols), None, dtype=object)
+        for i in range(self.ngrids):
+            col, row = self._get_col_row(i)
+            if share_all:
+                sharex = sharey = axes_array[0, 0]
+            else:
+                sharex = axes_array[0, col] if share_x else None
+                sharey = axes_array[row, 0] if share_y else None
+            axes_array[row, col] = axes_class(
+                fig, rect, sharex=sharex, sharey=sharey)
+        self.axes_all = axes_array.ravel(
+            order="C" if self._direction == "row" else "F").tolist()
+        self.axes_column = axes_array.T.tolist()
+        self.axes_row = axes_array.tolist()
+        self.axes_llc = self.axes_column[0][-1]
+
+        self._init_locators()
+
+        for ax in self.axes_all:
+            fig.add_axes(ax)
+
+        self.set_label_mode(label_mode)
+
+    def _init_locators(self):
+        self._divider.set_horizontal(
+            [Size.Scaled(1), self._horiz_pad_size] * (self._ncols-1) + [Size.Scaled(1)])
+        self._divider.set_vertical(
+            [Size.Scaled(1), self._vert_pad_size] * (self._nrows-1) + [Size.Scaled(1)])
+        for i in range(self.ngrids):
+            col, row = self._get_col_row(i)
+            self.axes_all[i].set_axes_locator(
+                self._divider.new_locator(nx=2 * col, ny=2 * (self._nrows - 1 - row)))
+
+    def _get_col_row(self, n):
+        if self._direction == "column":
+            col, row = divmod(n, self._nrows)
+        else:
+            row, col = divmod(n, self._ncols)
+
+        return col, row
+
+    # Good to propagate __len__ if we have __getitem__
+    def __len__(self):
+        return len(self.axes_all)
+
+    def __getitem__(self, i):
+        return self.axes_all[i]
+
+    def get_geometry(self):
+        """
+        Return the number of rows and columns of the grid as (nrows, ncols).
+        """
+        return self._nrows, self._ncols
+
+    def set_axes_pad(self, axes_pad):
+        """
+        Set the padding between the axes.
+
+        Parameters
+        ----------
+        axes_pad : (float, float)
+            The padding (horizontal pad, vertical pad) in inches.
+        """
+        self._horiz_pad_size.fixed_size = axes_pad[0]
+        self._vert_pad_size.fixed_size = axes_pad[1]
+
+    def get_axes_pad(self):
+        """
+        Return the axes padding.
+
+        Returns
+        -------
+        hpad, vpad
+            Padding (horizontal pad, vertical pad) in inches.
+        """
+        return (self._horiz_pad_size.fixed_size,
+                self._vert_pad_size.fixed_size)
+
+    def set_aspect(self, aspect):
+        """Set the aspect of the SubplotDivider."""
+        self._divider.set_aspect(aspect)
+
+    def get_aspect(self):
+        """Return the aspect of the SubplotDivider."""
+        return self._divider.get_aspect()
+
+    def set_label_mode(self, mode):
+        """
+        Define which axes have tick labels.
+
+        Parameters
+        ----------
+        mode : {"L", "1", "all", "keep"}
+            The label mode:
+
+            - "L": All axes on the left column get vertical tick labels;
+              all axes on the bottom row get horizontal tick labels.
+            - "1": Only the bottom left axes is labelled.
+            - "all": All axes are labelled.
+            - "keep": Do not do anything.
+        """
+        _api.check_in_list(["all", "L", "1", "keep"], mode=mode)
+        is_last_row, is_first_col = (
+            np.mgrid[:self._nrows, :self._ncols] == [[[self._nrows - 1]], [[0]]])
+        if mode == "all":
+            bottom = left = np.full((self._nrows, self._ncols), True)
+        elif mode == "L":
+            bottom = is_last_row
+            left = is_first_col
+        elif mode == "1":
+            bottom = left = is_last_row & is_first_col
+        else:
+            return
+        for i in range(self._nrows):
+            for j in range(self._ncols):
+                ax = self.axes_row[i][j]
+                if isinstance(ax.axis, MethodType):
+                    bottom_axis = SimpleAxisArtist(ax.xaxis, 1, ax.spines["bottom"])
+                    left_axis = SimpleAxisArtist(ax.yaxis, 1, ax.spines["left"])
+                else:
+                    bottom_axis = ax.axis["bottom"]
+                    left_axis = ax.axis["left"]
+                bottom_axis.toggle(ticklabels=bottom[i, j], label=bottom[i, j])
+                left_axis.toggle(ticklabels=left[i, j], label=left[i, j])
+
+    def get_divider(self):
+        return self._divider
+
+    def set_axes_locator(self, locator):
+        self._divider.set_locator(locator)
+
+    def get_axes_locator(self):
+        return self._divider.get_locator()
+
+
+class ImageGrid(Grid):
+    """
+    A grid of Axes for Image display.
+
+    This class is a specialization of `~.axes_grid1.axes_grid.Grid` for displaying a
+    grid of images.  In particular, it forces all axes in a column to share their x-axis
+    and all axes in a row to share their y-axis.  It further provides helpers to add
+    colorbars to some or all axes.
+    """
+
+    def __init__(self, fig,
+                 rect,
+                 nrows_ncols,
+                 ngrids=None,
+                 direction="row",
+                 axes_pad=0.02,
+                 *,
+                 share_all=False,
+                 aspect=True,
+                 label_mode="L",
+                 cbar_mode=None,
+                 cbar_location="right",
+                 cbar_pad=None,
+                 cbar_size="5%",
+                 cbar_set_cax=True,
+                 axes_class=None,
+                 ):
+        """
+        Parameters
+        ----------
+        fig : `.Figure`
+            The parent figure.
+        rect : (float, float, float, float) or int
+            The axes position, as a ``(left, bottom, width, height)`` tuple or
+            as a three-digit subplot position code (e.g., "121").
+        nrows_ncols : (int, int)
+            Number of rows and columns in the grid.
+        ngrids : int or None, default: None
+            If not None, only the first *ngrids* axes in the grid are created.
+        direction : {"row", "column"}, default: "row"
+            Whether axes are created in row-major ("row by row") or
+            column-major order ("column by column").  This also affects the
+            order in which axes are accessed using indexing (``grid[index]``).
+        axes_pad : float or (float, float), default: 0.02in
+            Padding or (horizontal padding, vertical padding) between axes, in
+            inches.
+        share_all : bool, default: False
+            Whether all axes share their x- and y-axis.  Note that in any case,
+            all axes in a column share their x-axis and all axes in a row share
+            their y-axis.
+        aspect : bool, default: True
+            Whether the axes aspect ratio follows the aspect ratio of the data
+            limits.
+        label_mode : {"L", "1", "all"}, default: "L"
+            Determines which axes will get tick labels:
+
+            - "L": All axes on the left column get vertical tick labels;
+              all axes on the bottom row get horizontal tick labels.
+            - "1": Only the bottom left axes is labelled.
+            - "all": all axes are labelled.
+
+        cbar_mode : {"each", "single", "edge", None}, default: None
+            Whether to create a colorbar for "each" axes, a "single" colorbar
+            for the entire grid, colorbars only for axes on the "edge"
+            determined by *cbar_location*, or no colorbars.  The colorbars are
+            stored in the :attr:`cbar_axes` attribute.
+        cbar_location : {"left", "right", "bottom", "top"}, default: "right"
+        cbar_pad : float, default: None
+            Padding between the image axes and the colorbar axes.
+        cbar_size : size specification (see `.Size.from_any`), default: "5%"
+            Colorbar size.
+        cbar_set_cax : bool, default: True
+            If True, each axes in the grid has a *cax* attribute that is bound
+            to associated *cbar_axes*.
+        axes_class : subclass of `matplotlib.axes.Axes`, default: None
+        """
+        _api.check_in_list(["each", "single", "edge", None],
+                           cbar_mode=cbar_mode)
+        _api.check_in_list(["left", "right", "bottom", "top"],
+                           cbar_location=cbar_location)
+        self._colorbar_mode = cbar_mode
+        self._colorbar_location = cbar_location
+        self._colorbar_pad = cbar_pad
+        self._colorbar_size = cbar_size
+        # The colorbar axes are created in _init_locators().
+
+        super().__init__(
+            fig, rect, nrows_ncols, ngrids,
+            direction=direction, axes_pad=axes_pad,
+            share_all=share_all, share_x=True, share_y=True, aspect=aspect,
+            label_mode=label_mode, axes_class=axes_class)
+
+        for ax in self.cbar_axes:
+            fig.add_axes(ax)
+
+        if cbar_set_cax:
+            if self._colorbar_mode == "single":
+                for ax in self.axes_all:
+                    ax.cax = self.cbar_axes[0]
+            elif self._colorbar_mode == "edge":
+                for index, ax in enumerate(self.axes_all):
+                    col, row = self._get_col_row(index)
+                    if self._colorbar_location in ("left", "right"):
+                        ax.cax = self.cbar_axes[row]
+                    else:
+                        ax.cax = self.cbar_axes[col]
+            else:
+                for ax, cax in zip(self.axes_all, self.cbar_axes):
+                    ax.cax = cax
+
+    def _init_locators(self):
+        # Slightly abusing this method to inject colorbar creation into init.
+
+        if self._colorbar_pad is None:
+            # horizontal or vertical arrangement?
+            if self._colorbar_location in ("left", "right"):
+                self._colorbar_pad = self._horiz_pad_size.fixed_size
+            else:
+                self._colorbar_pad = self._vert_pad_size.fixed_size
+        self.cbar_axes = [
+            _cbaraxes_class_factory(self._defaultAxesClass)(
+                self.axes_all[0].figure, self._divider.get_position(),
+                orientation=self._colorbar_location)
+            for _ in range(self.ngrids)]
+
+        cb_mode = self._colorbar_mode
+        cb_location = self._colorbar_location
+
+        h = []
+        v = []
+
+        h_ax_pos = []
+        h_cb_pos = []
+        if cb_mode == "single" and cb_location in ("left", "bottom"):
+            if cb_location == "left":
+                sz = self._nrows * Size.AxesX(self.axes_llc)
+                h.append(Size.from_any(self._colorbar_size, sz))
+                h.append(Size.from_any(self._colorbar_pad, sz))
+                locator = self._divider.new_locator(nx=0, ny=0, ny1=-1)
+            elif cb_location == "bottom":
+                sz = self._ncols * Size.AxesY(self.axes_llc)
+                v.append(Size.from_any(self._colorbar_size, sz))
+                v.append(Size.from_any(self._colorbar_pad, sz))
+                locator = self._divider.new_locator(nx=0, nx1=-1, ny=0)
+            for i in range(self.ngrids):
+                self.cbar_axes[i].set_visible(False)
+            self.cbar_axes[0].set_axes_locator(locator)
+            self.cbar_axes[0].set_visible(True)
+
+        for col, ax in enumerate(self.axes_row[0]):
+            if h:
+                h.append(self._horiz_pad_size)
+
+            if ax:
+                sz = Size.AxesX(ax, aspect="axes", ref_ax=self.axes_all[0])
+            else:
+                sz = Size.AxesX(self.axes_all[0],
+                                aspect="axes", ref_ax=self.axes_all[0])
+
+            if (cb_location == "left"
+                    and (cb_mode == "each"
+                         or (cb_mode == "edge" and col == 0))):
+                h_cb_pos.append(len(h))
+                h.append(Size.from_any(self._colorbar_size, sz))
+                h.append(Size.from_any(self._colorbar_pad, sz))
+
+            h_ax_pos.append(len(h))
+            h.append(sz)
+
+            if (cb_location == "right"
+                    and (cb_mode == "each"
+                         or (cb_mode == "edge" and col == self._ncols - 1))):
+                h.append(Size.from_any(self._colorbar_pad, sz))
+                h_cb_pos.append(len(h))
+                h.append(Size.from_any(self._colorbar_size, sz))
+
+        v_ax_pos = []
+        v_cb_pos = []
+        for row, ax in enumerate(self.axes_column[0][::-1]):
+            if v:
+                v.append(self._vert_pad_size)
+
+            if ax:
+                sz = Size.AxesY(ax, aspect="axes", ref_ax=self.axes_all[0])
+            else:
+                sz = Size.AxesY(self.axes_all[0],
+                                aspect="axes", ref_ax=self.axes_all[0])
+
+            if (cb_location == "bottom"
+                    and (cb_mode == "each"
+                         or (cb_mode == "edge" and row == 0))):
+                v_cb_pos.append(len(v))
+                v.append(Size.from_any(self._colorbar_size, sz))
+                v.append(Size.from_any(self._colorbar_pad, sz))
+
+            v_ax_pos.append(len(v))
+            v.append(sz)
+
+            if (cb_location == "top"
+                    and (cb_mode == "each"
+                         or (cb_mode == "edge" and row == self._nrows - 1))):
+                v.append(Size.from_any(self._colorbar_pad, sz))
+                v_cb_pos.append(len(v))
+                v.append(Size.from_any(self._colorbar_size, sz))
+
+        for i in range(self.ngrids):
+            col, row = self._get_col_row(i)
+            locator = self._divider.new_locator(nx=h_ax_pos[col],
+                                                ny=v_ax_pos[self._nrows-1-row])
+            self.axes_all[i].set_axes_locator(locator)
+
+            if cb_mode == "each":
+                if cb_location in ("right", "left"):
+                    locator = self._divider.new_locator(
+                        nx=h_cb_pos[col], ny=v_ax_pos[self._nrows - 1 - row])
+
+                elif cb_location in ("top", "bottom"):
+                    locator = self._divider.new_locator(
+                        nx=h_ax_pos[col], ny=v_cb_pos[self._nrows - 1 - row])
+
+                self.cbar_axes[i].set_axes_locator(locator)
+            elif cb_mode == "edge":
+                if (cb_location == "left" and col == 0
+                        or cb_location == "right" and col == self._ncols - 1):
+                    locator = self._divider.new_locator(
+                        nx=h_cb_pos[0], ny=v_ax_pos[self._nrows - 1 - row])
+                    self.cbar_axes[row].set_axes_locator(locator)
+                elif (cb_location == "bottom" and row == self._nrows - 1
+                      or cb_location == "top" and row == 0):
+                    locator = self._divider.new_locator(nx=h_ax_pos[col],
+                                                        ny=v_cb_pos[0])
+                    self.cbar_axes[col].set_axes_locator(locator)
+
+        if cb_mode == "single":
+            if cb_location == "right":
+                sz = self._nrows * Size.AxesX(self.axes_llc)
+                h.append(Size.from_any(self._colorbar_pad, sz))
+                h.append(Size.from_any(self._colorbar_size, sz))
+                locator = self._divider.new_locator(nx=-2, ny=0, ny1=-1)
+            elif cb_location == "top":
+                sz = self._ncols * Size.AxesY(self.axes_llc)
+                v.append(Size.from_any(self._colorbar_pad, sz))
+                v.append(Size.from_any(self._colorbar_size, sz))
+                locator = self._divider.new_locator(nx=0, nx1=-1, ny=-2)
+            if cb_location in ("right", "top"):
+                for i in range(self.ngrids):
+                    self.cbar_axes[i].set_visible(False)
+                self.cbar_axes[0].set_axes_locator(locator)
+                self.cbar_axes[0].set_visible(True)
+        elif cb_mode == "each":
+            for i in range(self.ngrids):
+                self.cbar_axes[i].set_visible(True)
+        elif cb_mode == "edge":
+            if cb_location in ("right", "left"):
+                count = self._nrows
+            else:
+                count = self._ncols
+            for i in range(count):
+                self.cbar_axes[i].set_visible(True)
+            for j in range(i + 1, self.ngrids):
+                self.cbar_axes[j].set_visible(False)
+        else:
+            for i in range(self.ngrids):
+                self.cbar_axes[i].set_visible(False)
+                self.cbar_axes[i].set_position([1., 1., 0.001, 0.001],
+                                               which="active")
+
+        self._divider.set_horizontal(h)
+        self._divider.set_vertical(v)
+
+
+AxesGrid = ImageGrid
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_rgb.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_rgb.py
new file mode 100644
index 0000000000000000000000000000000000000000..52fd707e87043eb17929a84c53da2741722ce002
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_rgb.py
@@ -0,0 +1,157 @@
+from types import MethodType
+
+import numpy as np
+
+from .axes_divider import make_axes_locatable, Size
+from .mpl_axes import Axes, SimpleAxisArtist
+
+
+def make_rgb_axes(ax, pad=0.01, axes_class=None, **kwargs):
+    """
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        Axes instance to create the RGB Axes in.
+    pad : float, optional
+        Fraction of the Axes height to pad.
+    axes_class : `matplotlib.axes.Axes` or None, optional
+        Axes class to use for the R, G, and B Axes. If None, use
+        the same class as *ax*.
+    **kwargs
+        Forwarded to *axes_class* init for the R, G, and B Axes.
+    """
+
+    divider = make_axes_locatable(ax)
+
+    pad_size = pad * Size.AxesY(ax)
+
+    xsize = ((1-2*pad)/3) * Size.AxesX(ax)
+    ysize = ((1-2*pad)/3) * Size.AxesY(ax)
+
+    divider.set_horizontal([Size.AxesX(ax), pad_size, xsize])
+    divider.set_vertical([ysize, pad_size, ysize, pad_size, ysize])
+
+    ax.set_axes_locator(divider.new_locator(0, 0, ny1=-1))
+
+    ax_rgb = []
+    if axes_class is None:
+        axes_class = type(ax)
+
+    for ny in [4, 2, 0]:
+        ax1 = axes_class(ax.get_figure(), ax.get_position(original=True),
+                         sharex=ax, sharey=ax, **kwargs)
+        locator = divider.new_locator(nx=2, ny=ny)
+        ax1.set_axes_locator(locator)
+        for t in ax1.yaxis.get_ticklabels() + ax1.xaxis.get_ticklabels():
+            t.set_visible(False)
+        try:
+            for axis in ax1.axis.values():
+                axis.major_ticklabels.set_visible(False)
+        except AttributeError:
+            pass
+
+        ax_rgb.append(ax1)
+
+    fig = ax.get_figure()
+    for ax1 in ax_rgb:
+        fig.add_axes(ax1)
+
+    return ax_rgb
+
+
+class RGBAxes:
+    """
+    4-panel `~.Axes.imshow` (RGB, R, G, B).
+
+    Layout::
+
+        ┌───────────────┬─────┐
+        │               │  R  │
+        │               ├─────┤
+        │      RGB      │  G  │
+        │               ├─────┤
+        │               │  B  │
+        └───────────────┴─────┘
+
+    Subclasses can override the ``_defaultAxesClass`` attribute.
+    By default RGBAxes uses `.mpl_axes.Axes`.
+
+    Attributes
+    ----------
+    RGB : ``_defaultAxesClass``
+        The Axes object for the three-channel `~.Axes.imshow`.
+    R : ``_defaultAxesClass``
+        The Axes object for the red channel `~.Axes.imshow`.
+    G : ``_defaultAxesClass``
+        The Axes object for the green channel `~.Axes.imshow`.
+    B : ``_defaultAxesClass``
+        The Axes object for the blue channel `~.Axes.imshow`.
+    """
+
+    _defaultAxesClass = Axes
+
+    def __init__(self, *args, pad=0, **kwargs):
+        """
+        Parameters
+        ----------
+        pad : float, default: 0
+            Fraction of the Axes height to put as padding.
+        axes_class : `~matplotlib.axes.Axes`
+            Axes class to use. If not provided, ``_defaultAxesClass`` is used.
+        *args
+            Forwarded to *axes_class* init for the RGB Axes
+        **kwargs
+            Forwarded to *axes_class* init for the RGB, R, G, and B Axes
+        """
+        axes_class = kwargs.pop("axes_class", self._defaultAxesClass)
+        self.RGB = ax = axes_class(*args, **kwargs)
+        ax.get_figure().add_axes(ax)
+        self.R, self.G, self.B = make_rgb_axes(
+            ax, pad=pad, axes_class=axes_class, **kwargs)
+        # Set the line color and ticks for the axes.
+        for ax1 in [self.RGB, self.R, self.G, self.B]:
+            if isinstance(ax1.axis, MethodType):
+                ad = Axes.AxisDict(self)
+                ad.update(
+                    bottom=SimpleAxisArtist(ax1.xaxis, 1, ax1.spines["bottom"]),
+                    top=SimpleAxisArtist(ax1.xaxis, 2, ax1.spines["top"]),
+                    left=SimpleAxisArtist(ax1.yaxis, 1, ax1.spines["left"]),
+                    right=SimpleAxisArtist(ax1.yaxis, 2, ax1.spines["right"]))
+            else:
+                ad = ax1.axis
+            ad[:].line.set_color("w")
+            ad[:].major_ticks.set_markeredgecolor("w")
+
+    def imshow_rgb(self, r, g, b, **kwargs):
+        """
+        Create the four images {rgb, r, g, b}.
+
+        Parameters
+        ----------
+        r, g, b : array-like
+            The red, green, and blue arrays.
+        **kwargs
+            Forwarded to `~.Axes.imshow` calls for the four images.
+
+        Returns
+        -------
+        rgb : `~matplotlib.image.AxesImage`
+        r : `~matplotlib.image.AxesImage`
+        g : `~matplotlib.image.AxesImage`
+        b : `~matplotlib.image.AxesImage`
+        """
+        if not (r.shape == g.shape == b.shape):
+            raise ValueError(
+                f'Input shapes ({r.shape}, {g.shape}, {b.shape}) do not match')
+        RGB = np.dstack([r, g, b])
+        R = np.zeros_like(RGB)
+        R[:, :, 0] = r
+        G = np.zeros_like(RGB)
+        G[:, :, 1] = g
+        B = np.zeros_like(RGB)
+        B[:, :, 2] = b
+        im_rgb = self.RGB.imshow(RGB, **kwargs)
+        im_r = self.R.imshow(R, **kwargs)
+        im_g = self.G.imshow(G, **kwargs)
+        im_b = self.B.imshow(B, **kwargs)
+        return im_rgb, im_r, im_g, im_b
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_size.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_size.py
new file mode 100644
index 0000000000000000000000000000000000000000..e417c1a899ac9823e757f2b490aeb354223f8f2b
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/axes_size.py
@@ -0,0 +1,248 @@
+"""
+Provides classes of simple units that will be used with `.AxesDivider`
+class (or others) to determine the size of each Axes. The unit
+classes define `get_size` method that returns a tuple of two floats,
+meaning relative and absolute sizes, respectively.
+
+Note that this class is nothing more than a simple tuple of two
+floats. Take a look at the Divider class to see how these two
+values are used.
+"""
+
+from numbers import Real
+
+from matplotlib import _api
+from matplotlib.axes import Axes
+
+
+class _Base:
+    def __rmul__(self, other):
+        return Fraction(other, self)
+
+    def __add__(self, other):
+        if isinstance(other, _Base):
+            return Add(self, other)
+        else:
+            return Add(self, Fixed(other))
+
+    def get_size(self, renderer):
+        """
+        Return two-float tuple with relative and absolute sizes.
+        """
+        raise NotImplementedError("Subclasses must implement")
+
+
+class Add(_Base):
+    """
+    Sum of two sizes.
+    """
+
+    def __init__(self, a, b):
+        self._a = a
+        self._b = b
+
+    def get_size(self, renderer):
+        a_rel_size, a_abs_size = self._a.get_size(renderer)
+        b_rel_size, b_abs_size = self._b.get_size(renderer)
+        return a_rel_size + b_rel_size, a_abs_size + b_abs_size
+
+
+class Fixed(_Base):
+    """
+    Simple fixed size with absolute part = *fixed_size* and relative part = 0.
+    """
+
+    def __init__(self, fixed_size):
+        _api.check_isinstance(Real, fixed_size=fixed_size)
+        self.fixed_size = fixed_size
+
+    def get_size(self, renderer):
+        rel_size = 0.
+        abs_size = self.fixed_size
+        return rel_size, abs_size
+
+
+class Scaled(_Base):
+    """
+    Simple scaled(?) size with absolute part = 0 and
+    relative part = *scalable_size*.
+    """
+
+    def __init__(self, scalable_size):
+        self._scalable_size = scalable_size
+
+    def get_size(self, renderer):
+        rel_size = self._scalable_size
+        abs_size = 0.
+        return rel_size, abs_size
+
+Scalable = Scaled
+
+
+def _get_axes_aspect(ax):
+    aspect = ax.get_aspect()
+    if aspect == "auto":
+        aspect = 1.
+    return aspect
+
+
+class AxesX(_Base):
+    """
+    Scaled size whose relative part corresponds to the data width
+    of the *axes* multiplied by the *aspect*.
+    """
+
+    def __init__(self, axes, aspect=1., ref_ax=None):
+        self._axes = axes
+        self._aspect = aspect
+        if aspect == "axes" and ref_ax is None:
+            raise ValueError("ref_ax must be set when aspect='axes'")
+        self._ref_ax = ref_ax
+
+    def get_size(self, renderer):
+        l1, l2 = self._axes.get_xlim()
+        if self._aspect == "axes":
+            ref_aspect = _get_axes_aspect(self._ref_ax)
+            aspect = ref_aspect / _get_axes_aspect(self._axes)
+        else:
+            aspect = self._aspect
+
+        rel_size = abs(l2-l1)*aspect
+        abs_size = 0.
+        return rel_size, abs_size
+
+
+class AxesY(_Base):
+    """
+    Scaled size whose relative part corresponds to the data height
+    of the *axes* multiplied by the *aspect*.
+    """
+
+    def __init__(self, axes, aspect=1., ref_ax=None):
+        self._axes = axes
+        self._aspect = aspect
+        if aspect == "axes" and ref_ax is None:
+            raise ValueError("ref_ax must be set when aspect='axes'")
+        self._ref_ax = ref_ax
+
+    def get_size(self, renderer):
+        l1, l2 = self._axes.get_ylim()
+
+        if self._aspect == "axes":
+            ref_aspect = _get_axes_aspect(self._ref_ax)
+            aspect = _get_axes_aspect(self._axes)
+        else:
+            aspect = self._aspect
+
+        rel_size = abs(l2-l1)*aspect
+        abs_size = 0.
+        return rel_size, abs_size
+
+
+class MaxExtent(_Base):
+    """
+    Size whose absolute part is either the largest width or the largest height
+    of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list, w_or_h):
+        self._artist_list = artist_list
+        _api.check_in_list(["width", "height"], w_or_h=w_or_h)
+        self._w_or_h = w_or_h
+
+    def add_artist(self, a):
+        self._artist_list.append(a)
+
+    def get_size(self, renderer):
+        rel_size = 0.
+        extent_list = [
+            getattr(a.get_window_extent(renderer), self._w_or_h) / a.figure.dpi
+            for a in self._artist_list]
+        abs_size = max(extent_list, default=0)
+        return rel_size, abs_size
+
+
+class MaxWidth(MaxExtent):
+    """
+    Size whose absolute part is the largest width of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list):
+        super().__init__(artist_list, "width")
+
+
+class MaxHeight(MaxExtent):
+    """
+    Size whose absolute part is the largest height of the given *artist_list*.
+    """
+
+    def __init__(self, artist_list):
+        super().__init__(artist_list, "height")
+
+
+class Fraction(_Base):
+    """
+    An instance whose size is a *fraction* of the *ref_size*.
+
+    >>> s = Fraction(0.3, AxesX(ax))
+    """
+
+    def __init__(self, fraction, ref_size):
+        _api.check_isinstance(Real, fraction=fraction)
+        self._fraction_ref = ref_size
+        self._fraction = fraction
+
+    def get_size(self, renderer):
+        if self._fraction_ref is None:
+            return self._fraction, 0.
+        else:
+            r, a = self._fraction_ref.get_size(renderer)
+            rel_size = r*self._fraction
+            abs_size = a*self._fraction
+            return rel_size, abs_size
+
+
+def from_any(size, fraction_ref=None):
+    """
+    Create a Fixed unit when the first argument is a float, or a
+    Fraction unit if that is a string that ends with %. The second
+    argument is only meaningful when Fraction unit is created.
+
+    >>> from mpl_toolkits.axes_grid1.axes_size import from_any
+    >>> a = from_any(1.2) # => Fixed(1.2)
+    >>> from_any("50%", a) # => Fraction(0.5, a)
+    """
+    if isinstance(size, Real):
+        return Fixed(size)
+    elif isinstance(size, str):
+        if size[-1] == "%":
+            return Fraction(float(size[:-1]) / 100, fraction_ref)
+    raise ValueError("Unknown format")
+
+
+class _AxesDecorationsSize(_Base):
+    """
+    Fixed size, corresponding to the size of decorations on a given Axes side.
+    """
+
+    _get_size_map = {
+        "left":   lambda tight_bb, axes_bb: axes_bb.xmin - tight_bb.xmin,
+        "right":  lambda tight_bb, axes_bb: tight_bb.xmax - axes_bb.xmax,
+        "bottom": lambda tight_bb, axes_bb: axes_bb.ymin - tight_bb.ymin,
+        "top":    lambda tight_bb, axes_bb: tight_bb.ymax - axes_bb.ymax,
+    }
+
+    def __init__(self, ax, direction):
+        _api.check_in_list(self._get_size_map, direction=direction)
+        self._direction = direction
+        self._ax_list = [ax] if isinstance(ax, Axes) else ax
+
+    def get_size(self, renderer):
+        sz = max([
+            self._get_size_map[self._direction](
+                ax.get_tightbbox(renderer, call_axes_locator=False), ax.bbox)
+            for ax in self._ax_list])
+        dpi = renderer.points_to_pixels(72)
+        abs_size = sz / dpi
+        rel_size = 0
+        return rel_size, abs_size
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/inset_locator.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/inset_locator.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d591a45311b9fbb4ce6459ae77e6c8827db1d42
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/inset_locator.py
@@ -0,0 +1,561 @@
+"""
+A collection of functions and objects for creating or placing inset axes.
+"""
+
+from matplotlib import _api, _docstring
+from matplotlib.offsetbox import AnchoredOffsetbox
+from matplotlib.patches import Patch, Rectangle
+from matplotlib.path import Path
+from matplotlib.transforms import Bbox, BboxTransformTo
+from matplotlib.transforms import IdentityTransform, TransformedBbox
+
+from . import axes_size as Size
+from .parasite_axes import HostAxes
+
+
+@_api.deprecated("3.8", alternative="Axes.inset_axes")
+class InsetPosition:
+    @_docstring.dedent_interpd
+    def __init__(self, parent, lbwh):
+        """
+        An object for positioning an inset axes.
+
+        This is created by specifying the normalized coordinates in the axes,
+        instead of the figure.
+
+        Parameters
+        ----------
+        parent : `~matplotlib.axes.Axes`
+            Axes to use for normalizing coordinates.
+
+        lbwh : iterable of four floats
+            The left edge, bottom edge, width, and height of the inset axes, in
+            units of the normalized coordinate of the *parent* axes.
+
+        See Also
+        --------
+        :meth:`matplotlib.axes.Axes.set_axes_locator`
+
+        Examples
+        --------
+        The following bounds the inset axes to a box with 20%% of the parent
+        axes height and 40%% of the width. The size of the axes specified
+        ([0, 0, 1, 1]) ensures that the axes completely fills the bounding box:
+
+        >>> parent_axes = plt.gca()
+        >>> ax_ins = plt.axes([0, 0, 1, 1])
+        >>> ip = InsetPosition(parent_axes, [0.5, 0.1, 0.4, 0.2])
+        >>> ax_ins.set_axes_locator(ip)
+        """
+        self.parent = parent
+        self.lbwh = lbwh
+
+    def __call__(self, ax, renderer):
+        bbox_parent = self.parent.get_position(original=False)
+        trans = BboxTransformTo(bbox_parent)
+        bbox_inset = Bbox.from_bounds(*self.lbwh)
+        bb = TransformedBbox(bbox_inset, trans)
+        return bb
+
+
+class AnchoredLocatorBase(AnchoredOffsetbox):
+    def __init__(self, bbox_to_anchor, offsetbox, loc,
+                 borderpad=0.5, bbox_transform=None):
+        super().__init__(
+            loc, pad=0., child=None, borderpad=borderpad,
+            bbox_to_anchor=bbox_to_anchor, bbox_transform=bbox_transform
+        )
+
+    def draw(self, renderer):
+        raise RuntimeError("No draw method should be called")
+
+    def __call__(self, ax, renderer):
+        if renderer is None:
+            renderer = ax.figure._get_renderer()
+        self.axes = ax
+        bbox = self.get_window_extent(renderer)
+        px, py = self.get_offset(bbox.width, bbox.height, 0, 0, renderer)
+        bbox_canvas = Bbox.from_bounds(px, py, bbox.width, bbox.height)
+        tr = ax.figure.transSubfigure.inverted()
+        return TransformedBbox(bbox_canvas, tr)
+
+
+class AnchoredSizeLocator(AnchoredLocatorBase):
+    def __init__(self, bbox_to_anchor, x_size, y_size, loc,
+                 borderpad=0.5, bbox_transform=None):
+        super().__init__(
+            bbox_to_anchor, None, loc,
+            borderpad=borderpad, bbox_transform=bbox_transform
+        )
+
+        self.x_size = Size.from_any(x_size)
+        self.y_size = Size.from_any(y_size)
+
+    def get_bbox(self, renderer):
+        bbox = self.get_bbox_to_anchor()
+        dpi = renderer.points_to_pixels(72.)
+
+        r, a = self.x_size.get_size(renderer)
+        width = bbox.width * r + a * dpi
+        r, a = self.y_size.get_size(renderer)
+        height = bbox.height * r + a * dpi
+
+        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
+        pad = self.pad * fontsize
+
+        return Bbox.from_bounds(0, 0, width, height).padded(pad)
+
+
+class AnchoredZoomLocator(AnchoredLocatorBase):
+    def __init__(self, parent_axes, zoom, loc,
+                 borderpad=0.5,
+                 bbox_to_anchor=None,
+                 bbox_transform=None):
+        self.parent_axes = parent_axes
+        self.zoom = zoom
+        if bbox_to_anchor is None:
+            bbox_to_anchor = parent_axes.bbox
+        super().__init__(
+            bbox_to_anchor, None, loc, borderpad=borderpad,
+            bbox_transform=bbox_transform)
+
+    def get_bbox(self, renderer):
+        bb = self.parent_axes.transData.transform_bbox(self.axes.viewLim)
+        fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
+        pad = self.pad * fontsize
+        return (
+            Bbox.from_bounds(
+                0, 0, abs(bb.width * self.zoom), abs(bb.height * self.zoom))
+            .padded(pad))
+
+
+class BboxPatch(Patch):
+    @_docstring.dedent_interpd
+    def __init__(self, bbox, **kwargs):
+        """
+        Patch showing the shape bounded by a Bbox.
+
+        Parameters
+        ----------
+        bbox : `~matplotlib.transforms.Bbox`
+            Bbox to use for the extents of this patch.
+
+        **kwargs
+            Patch properties. Valid arguments include:
+
+            %(Patch:kwdoc)s
+        """
+        if "transform" in kwargs:
+            raise ValueError("transform should not be set")
+
+        kwargs["transform"] = IdentityTransform()
+        super().__init__(**kwargs)
+        self.bbox = bbox
+
+    def get_path(self):
+        # docstring inherited
+        x0, y0, x1, y1 = self.bbox.extents
+        return Path._create_closed([(x0, y0), (x1, y0), (x1, y1), (x0, y1)])
+
+
+class BboxConnector(Patch):
+    @staticmethod
+    def get_bbox_edge_pos(bbox, loc):
+        """
+        Return the ``(x, y)`` coordinates of corner *loc* of *bbox*; parameters
+        behave as documented for the `.BboxConnector` constructor.
+        """
+        x0, y0, x1, y1 = bbox.extents
+        if loc == 1:
+            return x1, y1
+        elif loc == 2:
+            return x0, y1
+        elif loc == 3:
+            return x0, y0
+        elif loc == 4:
+            return x1, y0
+
+    @staticmethod
+    def connect_bbox(bbox1, bbox2, loc1, loc2=None):
+        """
+        Construct a `.Path` connecting corner *loc1* of *bbox1* to corner
+        *loc2* of *bbox2*, where parameters behave as documented as for the
+        `.BboxConnector` constructor.
+        """
+        if isinstance(bbox1, Rectangle):
+            bbox1 = TransformedBbox(Bbox.unit(), bbox1.get_transform())
+        if isinstance(bbox2, Rectangle):
+            bbox2 = TransformedBbox(Bbox.unit(), bbox2.get_transform())
+        if loc2 is None:
+            loc2 = loc1
+        x1, y1 = BboxConnector.get_bbox_edge_pos(bbox1, loc1)
+        x2, y2 = BboxConnector.get_bbox_edge_pos(bbox2, loc2)
+        return Path([[x1, y1], [x2, y2]])
+
+    @_docstring.dedent_interpd
+    def __init__(self, bbox1, bbox2, loc1, loc2=None, **kwargs):
+        """
+        Connect two bboxes with a straight line.
+
+        Parameters
+        ----------
+        bbox1, bbox2 : `~matplotlib.transforms.Bbox`
+            Bounding boxes to connect.
+
+        loc1, loc2 : {1, 2, 3, 4}
+            Corner of *bbox1* and *bbox2* to draw the line. Valid values are::
+
+                'upper right'  : 1,
+                'upper left'   : 2,
+                'lower left'   : 3,
+                'lower right'  : 4
+
+            *loc2* is optional and defaults to *loc1*.
+
+        **kwargs
+            Patch properties for the line drawn. Valid arguments include:
+
+            %(Patch:kwdoc)s
+        """
+        if "transform" in kwargs:
+            raise ValueError("transform should not be set")
+
+        kwargs["transform"] = IdentityTransform()
+        kwargs.setdefault(
+            "fill", bool({'fc', 'facecolor', 'color'}.intersection(kwargs)))
+        super().__init__(**kwargs)
+        self.bbox1 = bbox1
+        self.bbox2 = bbox2
+        self.loc1 = loc1
+        self.loc2 = loc2
+
+    def get_path(self):
+        # docstring inherited
+        return self.connect_bbox(self.bbox1, self.bbox2,
+                                 self.loc1, self.loc2)
+
+
+class BboxConnectorPatch(BboxConnector):
+    @_docstring.dedent_interpd
+    def __init__(self, bbox1, bbox2, loc1a, loc2a, loc1b, loc2b, **kwargs):
+        """
+        Connect two bboxes with a quadrilateral.
+
+        The quadrilateral is specified by two lines that start and end at
+        corners of the bboxes. The four sides of the quadrilateral are defined
+        by the two lines given, the line between the two corners specified in
+        *bbox1* and the line between the two corners specified in *bbox2*.
+
+        Parameters
+        ----------
+        bbox1, bbox2 : `~matplotlib.transforms.Bbox`
+            Bounding boxes to connect.
+
+        loc1a, loc2a, loc1b, loc2b : {1, 2, 3, 4}
+            The first line connects corners *loc1a* of *bbox1* and *loc2a* of
+            *bbox2*; the second line connects corners *loc1b* of *bbox1* and
+            *loc2b* of *bbox2*.  Valid values are::
+
+                'upper right'  : 1,
+                'upper left'   : 2,
+                'lower left'   : 3,
+                'lower right'  : 4
+
+        **kwargs
+            Patch properties for the line drawn:
+
+            %(Patch:kwdoc)s
+        """
+        if "transform" in kwargs:
+            raise ValueError("transform should not be set")
+        super().__init__(bbox1, bbox2, loc1a, loc2a, **kwargs)
+        self.loc1b = loc1b
+        self.loc2b = loc2b
+
+    def get_path(self):
+        # docstring inherited
+        path1 = self.connect_bbox(self.bbox1, self.bbox2, self.loc1, self.loc2)
+        path2 = self.connect_bbox(self.bbox2, self.bbox1,
+                                  self.loc2b, self.loc1b)
+        path_merged = [*path1.vertices, *path2.vertices, path1.vertices[0]]
+        return Path(path_merged)
+
+
+def _add_inset_axes(parent_axes, axes_class, axes_kwargs, axes_locator):
+    """Helper function to add an inset axes and disable navigation in it."""
+    if axes_class is None:
+        axes_class = HostAxes
+    if axes_kwargs is None:
+        axes_kwargs = {}
+    inset_axes = axes_class(
+        parent_axes.figure, parent_axes.get_position(),
+        **{"navigate": False, **axes_kwargs, "axes_locator": axes_locator})
+    return parent_axes.figure.add_axes(inset_axes)
+
+
+@_docstring.dedent_interpd
+def inset_axes(parent_axes, width, height, loc='upper right',
+               bbox_to_anchor=None, bbox_transform=None,
+               axes_class=None, axes_kwargs=None,
+               borderpad=0.5):
+    """
+    Create an inset axes with a given width and height.
+
+    Both sizes used can be specified either in inches or percentage.
+    For example,::
+
+        inset_axes(parent_axes, width='40%%', height='30%%', loc='lower left')
+
+    creates in inset axes in the lower left corner of *parent_axes* which spans
+    over 30%% in height and 40%% in width of the *parent_axes*. Since the usage
+    of `.inset_axes` may become slightly tricky when exceeding such standard
+    cases, it is recommended to read :doc:`the examples
+    </gallery/axes_grid1/inset_locator_demo>`.
+
+    Notes
+    -----
+    The meaning of *bbox_to_anchor* and *bbox_to_transform* is interpreted
+    differently from that of legend. The value of bbox_to_anchor
+    (or the return value of its get_points method; the default is
+    *parent_axes.bbox*) is transformed by the bbox_transform (the default
+    is Identity transform) and then interpreted as points in the pixel
+    coordinate (which is dpi dependent).
+
+    Thus, following three calls are identical and creates an inset axes
+    with respect to the *parent_axes*::
+
+       axins = inset_axes(parent_axes, "30%%", "40%%")
+       axins = inset_axes(parent_axes, "30%%", "40%%",
+                          bbox_to_anchor=parent_axes.bbox)
+       axins = inset_axes(parent_axes, "30%%", "40%%",
+                          bbox_to_anchor=(0, 0, 1, 1),
+                          bbox_transform=parent_axes.transAxes)
+
+    Parameters
+    ----------
+    parent_axes : `matplotlib.axes.Axes`
+        Axes to place the inset axes.
+
+    width, height : float or str
+        Size of the inset axes to create. If a float is provided, it is
+        the size in inches, e.g. *width=1.3*. If a string is provided, it is
+        the size in relative units, e.g. *width='40%%'*. By default, i.e. if
+        neither *bbox_to_anchor* nor *bbox_transform* are specified, those
+        are relative to the parent_axes. Otherwise, they are to be understood
+        relative to the bounding box provided via *bbox_to_anchor*.
+
+    loc : str, default: 'upper right'
+        Location to place the inset axes.  Valid locations are
+        'upper left', 'upper center', 'upper right',
+        'center left', 'center', 'center right',
+        'lower left', 'lower center', 'lower right'.
+        For backward compatibility, numeric values are accepted as well.
+        See the parameter *loc* of `.Legend` for details.
+
+    bbox_to_anchor : tuple or `~matplotlib.transforms.BboxBase`, optional
+        Bbox that the inset axes will be anchored to. If None,
+        a tuple of (0, 0, 1, 1) is used if *bbox_transform* is set
+        to *parent_axes.transAxes* or *parent_axes.figure.transFigure*.
+        Otherwise, *parent_axes.bbox* is used. If a tuple, can be either
+        [left, bottom, width, height], or [left, bottom].
+        If the kwargs *width* and/or *height* are specified in relative units,
+        the 2-tuple [left, bottom] cannot be used. Note that,
+        unless *bbox_transform* is set, the units of the bounding box
+        are interpreted in the pixel coordinate. When using *bbox_to_anchor*
+        with tuple, it almost always makes sense to also specify
+        a *bbox_transform*. This might often be the axes transform
+        *parent_axes.transAxes*.
+
+    bbox_transform : `~matplotlib.transforms.Transform`, optional
+        Transformation for the bbox that contains the inset axes.
+        If None, a `.transforms.IdentityTransform` is used. The value
+        of *bbox_to_anchor* (or the return value of its get_points method)
+        is transformed by the *bbox_transform* and then interpreted
+        as points in the pixel coordinate (which is dpi dependent).
+        You may provide *bbox_to_anchor* in some normalized coordinate,
+        and give an appropriate transform (e.g., *parent_axes.transAxes*).
+
+    axes_class : `~matplotlib.axes.Axes` type, default: `.HostAxes`
+        The type of the newly created inset axes.
+
+    axes_kwargs : dict, optional
+        Keyword arguments to pass to the constructor of the inset axes.
+        Valid arguments include:
+
+        %(Axes:kwdoc)s
+
+    borderpad : float, default: 0.5
+        Padding between inset axes and the bbox_to_anchor.
+        The units are axes font size, i.e. for a default font size of 10 points
+        *borderpad = 0.5* is equivalent to a padding of 5 points.
+
+    Returns
+    -------
+    inset_axes : *axes_class*
+        Inset axes object created.
+    """
+
+    if (bbox_transform in [parent_axes.transAxes, parent_axes.figure.transFigure]
+            and bbox_to_anchor is None):
+        _api.warn_external("Using the axes or figure transform requires a "
+                           "bounding box in the respective coordinates. "
+                           "Using bbox_to_anchor=(0, 0, 1, 1) now.")
+        bbox_to_anchor = (0, 0, 1, 1)
+    if bbox_to_anchor is None:
+        bbox_to_anchor = parent_axes.bbox
+    if (isinstance(bbox_to_anchor, tuple) and
+            (isinstance(width, str) or isinstance(height, str))):
+        if len(bbox_to_anchor) != 4:
+            raise ValueError("Using relative units for width or height "
+                             "requires to provide a 4-tuple or a "
+                             "`Bbox` instance to `bbox_to_anchor.")
+    return _add_inset_axes(
+        parent_axes, axes_class, axes_kwargs,
+        AnchoredSizeLocator(
+            bbox_to_anchor, width, height, loc=loc,
+            bbox_transform=bbox_transform, borderpad=borderpad))
+
+
+@_docstring.dedent_interpd
+def zoomed_inset_axes(parent_axes, zoom, loc='upper right',
+                      bbox_to_anchor=None, bbox_transform=None,
+                      axes_class=None, axes_kwargs=None,
+                      borderpad=0.5):
+    """
+    Create an anchored inset axes by scaling a parent axes. For usage, also see
+    :doc:`the examples </gallery/axes_grid1/inset_locator_demo2>`.
+
+    Parameters
+    ----------
+    parent_axes : `~matplotlib.axes.Axes`
+        Axes to place the inset axes.
+
+    zoom : float
+        Scaling factor of the data axes. *zoom* > 1 will enlarge the
+        coordinates (i.e., "zoomed in"), while *zoom* < 1 will shrink the
+        coordinates (i.e., "zoomed out").
+
+    loc : str, default: 'upper right'
+        Location to place the inset axes.  Valid locations are
+        'upper left', 'upper center', 'upper right',
+        'center left', 'center', 'center right',
+        'lower left', 'lower center', 'lower right'.
+        For backward compatibility, numeric values are accepted as well.
+        See the parameter *loc* of `.Legend` for details.
+
+    bbox_to_anchor : tuple or `~matplotlib.transforms.BboxBase`, optional
+        Bbox that the inset axes will be anchored to. If None,
+        *parent_axes.bbox* is used. If a tuple, can be either
+        [left, bottom, width, height], or [left, bottom].
+        If the kwargs *width* and/or *height* are specified in relative units,
+        the 2-tuple [left, bottom] cannot be used. Note that
+        the units of the bounding box are determined through the transform
+        in use. When using *bbox_to_anchor* it almost always makes sense to
+        also specify a *bbox_transform*. This might often be the axes transform
+        *parent_axes.transAxes*.
+
+    bbox_transform : `~matplotlib.transforms.Transform`, optional
+        Transformation for the bbox that contains the inset axes.
+        If None, a `.transforms.IdentityTransform` is used (i.e. pixel
+        coordinates). This is useful when not providing any argument to
+        *bbox_to_anchor*. When using *bbox_to_anchor* it almost always makes
+        sense to also specify a *bbox_transform*. This might often be the
+        axes transform *parent_axes.transAxes*. Inversely, when specifying
+        the axes- or figure-transform here, be aware that not specifying
+        *bbox_to_anchor* will use *parent_axes.bbox*, the units of which are
+        in display (pixel) coordinates.
+
+    axes_class : `~matplotlib.axes.Axes` type, default: `.HostAxes`
+        The type of the newly created inset axes.
+
+    axes_kwargs : dict, optional
+        Keyword arguments to pass to the constructor of the inset axes.
+        Valid arguments include:
+
+        %(Axes:kwdoc)s
+
+    borderpad : float, default: 0.5
+        Padding between inset axes and the bbox_to_anchor.
+        The units are axes font size, i.e. for a default font size of 10 points
+        *borderpad = 0.5* is equivalent to a padding of 5 points.
+
+    Returns
+    -------
+    inset_axes : *axes_class*
+        Inset axes object created.
+    """
+
+    return _add_inset_axes(
+        parent_axes, axes_class, axes_kwargs,
+        AnchoredZoomLocator(
+            parent_axes, zoom=zoom, loc=loc,
+            bbox_to_anchor=bbox_to_anchor, bbox_transform=bbox_transform,
+            borderpad=borderpad))
+
+
+class _TransformedBboxWithCallback(TransformedBbox):
+    """
+    Variant of `.TransformBbox` which calls *callback* before returning points.
+
+    Used by `.mark_inset` to unstale the parent axes' viewlim as needed.
+    """
+
+    def __init__(self, *args, callback, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._callback = callback
+
+    def get_points(self):
+        self._callback()
+        return super().get_points()
+
+
+@_docstring.dedent_interpd
+def mark_inset(parent_axes, inset_axes, loc1, loc2, **kwargs):
+    """
+    Draw a box to mark the location of an area represented by an inset axes.
+
+    This function draws a box in *parent_axes* at the bounding box of
+    *inset_axes*, and shows a connection with the inset axes by drawing lines
+    at the corners, giving a "zoomed in" effect.
+
+    Parameters
+    ----------
+    parent_axes : `~matplotlib.axes.Axes`
+        Axes which contains the area of the inset axes.
+
+    inset_axes : `~matplotlib.axes.Axes`
+        The inset axes.
+
+    loc1, loc2 : {1, 2, 3, 4}
+        Corners to use for connecting the inset axes and the area in the
+        parent axes.
+
+    **kwargs
+        Patch properties for the lines and box drawn:
+
+        %(Patch:kwdoc)s
+
+    Returns
+    -------
+    pp : `~matplotlib.patches.Patch`
+        The patch drawn to represent the area of the inset axes.
+
+    p1, p2 : `~matplotlib.patches.Patch`
+        The patches connecting two corners of the inset axes and its area.
+    """
+    rect = _TransformedBboxWithCallback(
+        inset_axes.viewLim, parent_axes.transData,
+        callback=parent_axes._unstale_viewLim)
+
+    kwargs.setdefault("fill", bool({'fc', 'facecolor', 'color'}.intersection(kwargs)))
+    pp = BboxPatch(rect, **kwargs)
+    parent_axes.add_patch(pp)
+
+    p1 = BboxConnector(inset_axes.bbox, rect, loc1=loc1, **kwargs)
+    inset_axes.add_patch(p1)
+    p1.set_clip_on(False)
+    p2 = BboxConnector(inset_axes.bbox, rect, loc1=loc2, **kwargs)
+    inset_axes.add_patch(p2)
+    p2.set_clip_on(False)
+
+    return pp, p1, p2
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/mpl_axes.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/mpl_axes.py
new file mode 100644
index 0000000000000000000000000000000000000000..51c8748758cb6da3052f0e8b05ceba427d77a3f6
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/mpl_axes.py
@@ -0,0 +1,128 @@
+import matplotlib.axes as maxes
+from matplotlib.artist import Artist
+from matplotlib.axis import XAxis, YAxis
+
+
+class SimpleChainedObjects:
+    def __init__(self, objects):
+        self._objects = objects
+
+    def __getattr__(self, k):
+        _a = SimpleChainedObjects([getattr(a, k) for a in self._objects])
+        return _a
+
+    def __call__(self, *args, **kwargs):
+        for m in self._objects:
+            m(*args, **kwargs)
+
+
+class Axes(maxes.Axes):
+
+    class AxisDict(dict):
+        def __init__(self, axes):
+            self.axes = axes
+            super().__init__()
+
+        def __getitem__(self, k):
+            if isinstance(k, tuple):
+                r = SimpleChainedObjects(
+                    # super() within a list comprehension needs explicit args.
+                    [super(Axes.AxisDict, self).__getitem__(k1) for k1 in k])
+                return r
+            elif isinstance(k, slice):
+                if k.start is None and k.stop is None and k.step is None:
+                    return SimpleChainedObjects(list(self.values()))
+                else:
+                    raise ValueError("Unsupported slice")
+            else:
+                return dict.__getitem__(self, k)
+
+        def __call__(self, *v, **kwargs):
+            return maxes.Axes.axis(self.axes, *v, **kwargs)
+
+    @property
+    def axis(self):
+        return self._axislines
+
+    def clear(self):
+        # docstring inherited
+        super().clear()
+        # Init axis artists.
+        self._axislines = self.AxisDict(self)
+        self._axislines.update(
+            bottom=SimpleAxisArtist(self.xaxis, 1, self.spines["bottom"]),
+            top=SimpleAxisArtist(self.xaxis, 2, self.spines["top"]),
+            left=SimpleAxisArtist(self.yaxis, 1, self.spines["left"]),
+            right=SimpleAxisArtist(self.yaxis, 2, self.spines["right"]))
+
+
+class SimpleAxisArtist(Artist):
+    def __init__(self, axis, axisnum, spine):
+        self._axis = axis
+        self._axisnum = axisnum
+        self.line = spine
+
+        if isinstance(axis, XAxis):
+            self._axis_direction = ["bottom", "top"][axisnum-1]
+        elif isinstance(axis, YAxis):
+            self._axis_direction = ["left", "right"][axisnum-1]
+        else:
+            raise ValueError(
+                f"axis must be instance of XAxis or YAxis, but got {axis}")
+        super().__init__()
+
+    @property
+    def major_ticks(self):
+        tickline = "tick%dline" % self._axisnum
+        return SimpleChainedObjects([getattr(tick, tickline)
+                                     for tick in self._axis.get_major_ticks()])
+
+    @property
+    def major_ticklabels(self):
+        label = "label%d" % self._axisnum
+        return SimpleChainedObjects([getattr(tick, label)
+                                     for tick in self._axis.get_major_ticks()])
+
+    @property
+    def label(self):
+        return self._axis.label
+
+    def set_visible(self, b):
+        self.toggle(all=b)
+        self.line.set_visible(b)
+        self._axis.set_visible(True)
+        super().set_visible(b)
+
+    def set_label(self, txt):
+        self._axis.set_label_text(txt)
+
+    def toggle(self, all=None, ticks=None, ticklabels=None, label=None):
+
+        if all:
+            _ticks, _ticklabels, _label = True, True, True
+        elif all is not None:
+            _ticks, _ticklabels, _label = False, False, False
+        else:
+            _ticks, _ticklabels, _label = None, None, None
+
+        if ticks is not None:
+            _ticks = ticks
+        if ticklabels is not None:
+            _ticklabels = ticklabels
+        if label is not None:
+            _label = label
+
+        if _ticks is not None:
+            tickparam = {f"tick{self._axisnum}On": _ticks}
+            self._axis.set_tick_params(**tickparam)
+        if _ticklabels is not None:
+            tickparam = {f"label{self._axisnum}On": _ticklabels}
+            self._axis.set_tick_params(**tickparam)
+
+        if _label is not None:
+            pos = self._axis.get_label_position()
+            if (pos == self._axis_direction) and not _label:
+                self._axis.label.set_visible(False)
+            elif _label:
+                self._axis.label.set_visible(True)
+                self._axis.set_label_position(self._axis_direction)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/parasite_axes.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/parasite_axes.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a2b5957e844a00a7db8e04f9dc07b637ab85199
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/parasite_axes.py
@@ -0,0 +1,257 @@
+from matplotlib import _api, cbook
+import matplotlib.artist as martist
+import matplotlib.transforms as mtransforms
+from matplotlib.transforms import Bbox
+from .mpl_axes import Axes
+
+
+class ParasiteAxesBase:
+
+    def __init__(self, parent_axes, aux_transform=None,
+                 *, viewlim_mode=None, **kwargs):
+        self._parent_axes = parent_axes
+        self.transAux = aux_transform
+        self.set_viewlim_mode(viewlim_mode)
+        kwargs["frameon"] = False
+        super().__init__(parent_axes.figure, parent_axes._position, **kwargs)
+
+    def clear(self):
+        super().clear()
+        martist.setp(self.get_children(), visible=False)
+        self._get_lines = self._parent_axes._get_lines
+        self._parent_axes.callbacks._connect_picklable(
+            "xlim_changed", self._sync_lims)
+        self._parent_axes.callbacks._connect_picklable(
+            "ylim_changed", self._sync_lims)
+
+    def pick(self, mouseevent):
+        # This most likely goes to Artist.pick (depending on axes_class given
+        # to the factory), which only handles pick events registered on the
+        # axes associated with each child:
+        super().pick(mouseevent)
+        # But parasite axes are additionally given pick events from their host
+        # axes (cf. HostAxesBase.pick), which we handle here:
+        for a in self.get_children():
+            if (hasattr(mouseevent.inaxes, "parasites")
+                    and self in mouseevent.inaxes.parasites):
+                a.pick(mouseevent)
+
+    # aux_transform support
+
+    def _set_lim_and_transforms(self):
+        if self.transAux is not None:
+            self.transAxes = self._parent_axes.transAxes
+            self.transData = self.transAux + self._parent_axes.transData
+            self._xaxis_transform = mtransforms.blended_transform_factory(
+                self.transData, self.transAxes)
+            self._yaxis_transform = mtransforms.blended_transform_factory(
+                self.transAxes, self.transData)
+        else:
+            super()._set_lim_and_transforms()
+
+    def set_viewlim_mode(self, mode):
+        _api.check_in_list([None, "equal", "transform"], mode=mode)
+        self._viewlim_mode = mode
+
+    def get_viewlim_mode(self):
+        return self._viewlim_mode
+
+    def _sync_lims(self, parent):
+        viewlim = parent.viewLim.frozen()
+        mode = self.get_viewlim_mode()
+        if mode is None:
+            pass
+        elif mode == "equal":
+            self.viewLim.set(viewlim)
+        elif mode == "transform":
+            self.viewLim.set(viewlim.transformed(self.transAux.inverted()))
+        else:
+            _api.check_in_list([None, "equal", "transform"], mode=mode)
+
+    # end of aux_transform support
+
+
+parasite_axes_class_factory = cbook._make_class_factory(
+    ParasiteAxesBase, "{}Parasite")
+ParasiteAxes = parasite_axes_class_factory(Axes)
+
+
+class HostAxesBase:
+    def __init__(self, *args, **kwargs):
+        self.parasites = []
+        super().__init__(*args, **kwargs)
+
+    def get_aux_axes(
+            self, tr=None, viewlim_mode="equal", axes_class=None, **kwargs):
+        """
+        Add a parasite axes to this host.
+
+        Despite this method's name, this should actually be thought of as an
+        ``add_parasite_axes`` method.
+
+        .. versionchanged:: 3.7
+           Defaults to same base axes class as host axes.
+
+        Parameters
+        ----------
+        tr : `~matplotlib.transforms.Transform` or None, default: None
+            If a `.Transform`, the following relation will hold:
+            ``parasite.transData = tr + host.transData``.
+            If None, the parasite's and the host's ``transData`` are unrelated.
+        viewlim_mode : {"equal", "transform", None}, default: "equal"
+            How the parasite's view limits are set: directly equal to the
+            parent axes ("equal"), equal after application of *tr*
+            ("transform"), or independently (None).
+        axes_class : subclass type of `~matplotlib.axes.Axes`, optional
+            The `~.axes.Axes` subclass that is instantiated.  If None, the base
+            class of the host axes is used.
+        **kwargs
+            Other parameters are forwarded to the parasite axes constructor.
+        """
+        if axes_class is None:
+            axes_class = self._base_axes_class
+        parasite_axes_class = parasite_axes_class_factory(axes_class)
+        ax2 = parasite_axes_class(
+            self, tr, viewlim_mode=viewlim_mode, **kwargs)
+        # note that ax2.transData == tr + ax1.transData
+        # Anything you draw in ax2 will match the ticks and grids of ax1.
+        self.parasites.append(ax2)
+        ax2._remove_method = self.parasites.remove
+        return ax2
+
+    def draw(self, renderer):
+        orig_children_len = len(self._children)
+
+        locator = self.get_axes_locator()
+        if locator:
+            pos = locator(self, renderer)
+            self.set_position(pos, which="active")
+            self.apply_aspect(pos)
+        else:
+            self.apply_aspect()
+
+        rect = self.get_position()
+        for ax in self.parasites:
+            ax.apply_aspect(rect)
+            self._children.extend(ax.get_children())
+
+        super().draw(renderer)
+        del self._children[orig_children_len:]
+
+    def clear(self):
+        super().clear()
+        for ax in self.parasites:
+            ax.clear()
+
+    def pick(self, mouseevent):
+        super().pick(mouseevent)
+        # Also pass pick events on to parasite axes and, in turn, their
+        # children (cf. ParasiteAxesBase.pick)
+        for a in self.parasites:
+            a.pick(mouseevent)
+
+    def twinx(self, axes_class=None):
+        """
+        Create a twin of Axes with a shared x-axis but independent y-axis.
+
+        The y-axis of self will have ticks on the left and the returned axes
+        will have ticks on the right.
+        """
+        ax = self._add_twin_axes(axes_class, sharex=self)
+        self.axis["right"].set_visible(False)
+        ax.axis["right"].set_visible(True)
+        ax.axis["left", "top", "bottom"].set_visible(False)
+        return ax
+
+    def twiny(self, axes_class=None):
+        """
+        Create a twin of Axes with a shared y-axis but independent x-axis.
+
+        The x-axis of self will have ticks on the bottom and the returned axes
+        will have ticks on the top.
+        """
+        ax = self._add_twin_axes(axes_class, sharey=self)
+        self.axis["top"].set_visible(False)
+        ax.axis["top"].set_visible(True)
+        ax.axis["left", "right", "bottom"].set_visible(False)
+        return ax
+
+    def twin(self, aux_trans=None, axes_class=None):
+        """
+        Create a twin of Axes with no shared axis.
+
+        While self will have ticks on the left and bottom axis, the returned
+        axes will have ticks on the top and right axis.
+        """
+        if aux_trans is None:
+            aux_trans = mtransforms.IdentityTransform()
+        ax = self._add_twin_axes(
+            axes_class, aux_transform=aux_trans, viewlim_mode="transform")
+        self.axis["top", "right"].set_visible(False)
+        ax.axis["top", "right"].set_visible(True)
+        ax.axis["left", "bottom"].set_visible(False)
+        return ax
+
+    def _add_twin_axes(self, axes_class, **kwargs):
+        """
+        Helper for `.twinx`/`.twiny`/`.twin`.
+
+        *kwargs* are forwarded to the parasite axes constructor.
+        """
+        if axes_class is None:
+            axes_class = self._base_axes_class
+        ax = parasite_axes_class_factory(axes_class)(self, **kwargs)
+        self.parasites.append(ax)
+        ax._remove_method = self._remove_any_twin
+        return ax
+
+    def _remove_any_twin(self, ax):
+        self.parasites.remove(ax)
+        restore = ["top", "right"]
+        if ax._sharex:
+            restore.remove("top")
+        if ax._sharey:
+            restore.remove("right")
+        self.axis[tuple(restore)].set_visible(True)
+        self.axis[tuple(restore)].toggle(ticklabels=False, label=False)
+
+    @_api.make_keyword_only("3.8", "call_axes_locator")
+    def get_tightbbox(self, renderer=None, call_axes_locator=True,
+                      bbox_extra_artists=None):
+        bbs = [
+            *[ax.get_tightbbox(renderer, call_axes_locator=call_axes_locator)
+              for ax in self.parasites],
+            super().get_tightbbox(renderer,
+                                  call_axes_locator=call_axes_locator,
+                                  bbox_extra_artists=bbox_extra_artists)]
+        return Bbox.union([b for b in bbs if b.width != 0 or b.height != 0])
+
+
+host_axes_class_factory = host_subplot_class_factory = \
+    cbook._make_class_factory(HostAxesBase, "{}HostAxes", "_base_axes_class")
+HostAxes = SubplotHost = host_axes_class_factory(Axes)
+
+
+def host_axes(*args, axes_class=Axes, figure=None, **kwargs):
+    """
+    Create axes that can act as a hosts to parasitic axes.
+
+    Parameters
+    ----------
+    figure : `~matplotlib.figure.Figure`
+        Figure to which the axes will be added. Defaults to the current figure
+        `.pyplot.gcf()`.
+
+    *args, **kwargs
+        Will be passed on to the underlying `~.axes.Axes` object creation.
+    """
+    import matplotlib.pyplot as plt
+    host_axes_class = host_axes_class_factory(axes_class)
+    if figure is None:
+        figure = plt.gcf()
+    ax = host_axes_class(figure, *args, **kwargs)
+    figure.add_axes(ax)
+    return ax
+
+
+host_subplot = host_axes
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__init__.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea4d8ed16a6a24a8c15ab2956ef678a7f256cd80
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__init__.py
@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+# Check that the test directories exist
+if not (Path(__file__).parent / "baseline_images").exists():
+    raise OSError(
+        'The baseline image directory does not exist. '
+        'This is most likely because the test data is not installed. '
+        'You may need to install matplotlib from source to get the '
+        'test data.')
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06bba69e04adafa96c6caf7ec470aeb890c98088
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/conftest.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b11a63a8a13d76bc548b9e72031820e263ad8d0
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/conftest.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/test_axes_grid1.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/test_axes_grid1.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7a91c620389d2484af1b0d90c4188d98bbcd749
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/__pycache__/test_axes_grid1.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/conftest.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..61c2de3e07bac4db323f8704961264d123e01544
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/conftest.py
@@ -0,0 +1,2 @@
+from matplotlib.testing.conftest import (mpl_test_settings,  # noqa
+                                         pytest_configure, pytest_unconfigure)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/test_axes_grid1.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/test_axes_grid1.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c444f6ae1786cc07ff6afee3386c6c78cbc5aff
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axes_grid1/tests/test_axes_grid1.py
@@ -0,0 +1,792 @@
+from itertools import product
+import io
+import platform
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+from matplotlib import cbook
+from matplotlib.backend_bases import MouseEvent
+from matplotlib.colors import LogNorm
+from matplotlib.patches import Circle, Ellipse
+from matplotlib.transforms import Bbox, TransformedBbox
+from matplotlib.testing.decorators import (
+    check_figures_equal, image_comparison, remove_ticks_and_titles)
+
+from mpl_toolkits.axes_grid1 import (
+    axes_size as Size,
+    host_subplot, make_axes_locatable,
+    Grid, AxesGrid, ImageGrid)
+from mpl_toolkits.axes_grid1.anchored_artists import (
+    AnchoredAuxTransformBox, AnchoredDrawingArea, AnchoredEllipse,
+    AnchoredDirectionArrows, AnchoredSizeBar)
+from mpl_toolkits.axes_grid1.axes_divider import (
+    Divider, HBoxDivider, make_axes_area_auto_adjustable, SubplotDivider,
+    VBoxDivider)
+from mpl_toolkits.axes_grid1.axes_rgb import RGBAxes
+from mpl_toolkits.axes_grid1.inset_locator import (
+    zoomed_inset_axes, mark_inset, inset_axes, BboxConnectorPatch,
+    InsetPosition)
+import mpl_toolkits.axes_grid1.mpl_axes
+import pytest
+
+import numpy as np
+from numpy.testing import assert_array_equal, assert_array_almost_equal
+
+
+def test_divider_append_axes():
+    fig, ax = plt.subplots()
+    divider = make_axes_locatable(ax)
+    axs = {
+        "main": ax,
+        "top": divider.append_axes("top", 1.2, pad=0.1, sharex=ax),
+        "bottom": divider.append_axes("bottom", 1.2, pad=0.1, sharex=ax),
+        "left": divider.append_axes("left", 1.2, pad=0.1, sharey=ax),
+        "right": divider.append_axes("right", 1.2, pad=0.1, sharey=ax),
+    }
+    fig.canvas.draw()
+    bboxes = {k: axs[k].get_window_extent() for k in axs}
+    dpi = fig.dpi
+    assert bboxes["top"].height == pytest.approx(1.2 * dpi)
+    assert bboxes["bottom"].height == pytest.approx(1.2 * dpi)
+    assert bboxes["left"].width == pytest.approx(1.2 * dpi)
+    assert bboxes["right"].width == pytest.approx(1.2 * dpi)
+    assert bboxes["top"].y0 - bboxes["main"].y1 == pytest.approx(0.1 * dpi)
+    assert bboxes["main"].y0 - bboxes["bottom"].y1 == pytest.approx(0.1 * dpi)
+    assert bboxes["main"].x0 - bboxes["left"].x1 == pytest.approx(0.1 * dpi)
+    assert bboxes["right"].x0 - bboxes["main"].x1 == pytest.approx(0.1 * dpi)
+    assert bboxes["left"].y0 == bboxes["main"].y0 == bboxes["right"].y0
+    assert bboxes["left"].y1 == bboxes["main"].y1 == bboxes["right"].y1
+    assert bboxes["top"].x0 == bboxes["main"].x0 == bboxes["bottom"].x0
+    assert bboxes["top"].x1 == bboxes["main"].x1 == bboxes["bottom"].x1
+
+
+# Update style when regenerating the test image
+@image_comparison(['twin_axes_empty_and_removed'], extensions=["png"], tol=1,
+                  style=('classic', '_classic_test_patch'))
+def test_twin_axes_empty_and_removed():
+    # Purely cosmetic font changes (avoid overlap)
+    mpl.rcParams.update(
+        {"font.size": 8, "xtick.labelsize": 8, "ytick.labelsize": 8})
+    generators = ["twinx", "twiny", "twin"]
+    modifiers = ["", "host invisible", "twin removed", "twin invisible",
+                 "twin removed\nhost invisible"]
+    # Unmodified host subplot at the beginning for reference
+    h = host_subplot(len(modifiers)+1, len(generators), 2)
+    h.text(0.5, 0.5, "host_subplot",
+           horizontalalignment="center", verticalalignment="center")
+    # Host subplots with various modifications (twin*, visibility) applied
+    for i, (mod, gen) in enumerate(product(modifiers, generators),
+                                   len(generators) + 1):
+        h = host_subplot(len(modifiers)+1, len(generators), i)
+        t = getattr(h, gen)()
+        if "twin invisible" in mod:
+            t.axis[:].set_visible(False)
+        if "twin removed" in mod:
+            t.remove()
+        if "host invisible" in mod:
+            h.axis[:].set_visible(False)
+        h.text(0.5, 0.5, gen + ("\n" + mod if mod else ""),
+               horizontalalignment="center", verticalalignment="center")
+    plt.subplots_adjust(wspace=0.5, hspace=1)
+
+
+def test_twin_axes_both_with_units():
+    host = host_subplot(111)
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        host.plot_date([0, 1, 2], [0, 1, 2], xdate=False, ydate=True)
+    twin = host.twinx()
+    twin.plot(["a", "b", "c"])
+    assert host.get_yticklabels()[0].get_text() == "00:00:00"
+    assert twin.get_yticklabels()[0].get_text() == "a"
+
+
+def test_axesgrid_colorbar_log_smoketest():
+    fig = plt.figure()
+    grid = AxesGrid(fig, 111,  # modified to be only subplot
+                    nrows_ncols=(1, 1),
+                    ngrids=1,
+                    label_mode="L",
+                    cbar_location="top",
+                    cbar_mode="single",
+                    )
+
+    Z = 10000 * np.random.rand(10, 10)
+    im = grid[0].imshow(Z, interpolation="nearest", norm=LogNorm())
+
+    grid.cbar_axes[0].colorbar(im)
+
+
+def test_inset_colorbar_tight_layout_smoketest():
+    fig, ax = plt.subplots(1, 1)
+    pts = ax.scatter([0, 1], [0, 1], c=[1, 5])
+
+    cax = inset_axes(ax, width="3%", height="70%")
+    plt.colorbar(pts, cax=cax)
+
+    with pytest.warns(UserWarning, match="This figure includes Axes"):
+        # Will warn, but not raise an error
+        plt.tight_layout()
+
+
+@image_comparison(['inset_locator.png'], style='default', remove_text=True)
+def test_inset_locator():
+    fig, ax = plt.subplots(figsize=[5, 4])
+
+    # prepare the demo image
+    # Z is a 15x15 array
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+    extent = (-3, 4, -4, 3)
+    Z2 = np.zeros((150, 150))
+    ny, nx = Z.shape
+    Z2[30:30+ny, 30:30+nx] = Z
+
+    ax.imshow(Z2, extent=extent, interpolation="nearest",
+              origin="lower")
+
+    axins = zoomed_inset_axes(ax, zoom=6, loc='upper right')
+    axins.imshow(Z2, extent=extent, interpolation="nearest",
+                 origin="lower")
+    axins.yaxis.get_major_locator().set_params(nbins=7)
+    axins.xaxis.get_major_locator().set_params(nbins=7)
+    # sub region of the original image
+    x1, x2, y1, y2 = -1.5, -0.9, -2.5, -1.9
+    axins.set_xlim(x1, x2)
+    axins.set_ylim(y1, y2)
+
+    plt.xticks(visible=False)
+    plt.yticks(visible=False)
+
+    # draw a bbox of the region of the inset axes in the parent axes and
+    # connecting lines between the bbox and the inset axes area
+    mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5")
+
+    asb = AnchoredSizeBar(ax.transData,
+                          0.5,
+                          '0.5',
+                          loc='lower center',
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+
+@image_comparison(['inset_axes.png'], style='default', remove_text=True)
+def test_inset_axes():
+    fig, ax = plt.subplots(figsize=[5, 4])
+
+    # prepare the demo image
+    # Z is a 15x15 array
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+    extent = (-3, 4, -4, 3)
+    Z2 = np.zeros((150, 150))
+    ny, nx = Z.shape
+    Z2[30:30+ny, 30:30+nx] = Z
+
+    ax.imshow(Z2, extent=extent, interpolation="nearest",
+              origin="lower")
+
+    # creating our inset axes with a bbox_transform parameter
+    axins = inset_axes(ax, width=1., height=1., bbox_to_anchor=(1, 1),
+                       bbox_transform=ax.transAxes)
+
+    axins.imshow(Z2, extent=extent, interpolation="nearest",
+                 origin="lower")
+    axins.yaxis.get_major_locator().set_params(nbins=7)
+    axins.xaxis.get_major_locator().set_params(nbins=7)
+    # sub region of the original image
+    x1, x2, y1, y2 = -1.5, -0.9, -2.5, -1.9
+    axins.set_xlim(x1, x2)
+    axins.set_ylim(y1, y2)
+
+    plt.xticks(visible=False)
+    plt.yticks(visible=False)
+
+    # draw a bbox of the region of the inset axes in the parent axes and
+    # connecting lines between the bbox and the inset axes area
+    mark_inset(ax, axins, loc1=2, loc2=4, fc="none", ec="0.5")
+
+    asb = AnchoredSizeBar(ax.transData,
+                          0.5,
+                          '0.5',
+                          loc='lower center',
+                          pad=0.1, borderpad=0.5, sep=5,
+                          frameon=False)
+    ax.add_artist(asb)
+
+
+def test_inset_axes_complete():
+    dpi = 100
+    figsize = (6, 5)
+    fig, ax = plt.subplots(figsize=figsize, dpi=dpi)
+    fig.subplots_adjust(.1, .1, .9, .9)
+
+    ins = inset_axes(ax, width=2., height=2., borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+        ins.get_position().extents,
+        [(0.9*figsize[0]-2.)/figsize[0], (0.9*figsize[1]-2.)/figsize[1],
+         0.9, 0.9])
+
+    ins = inset_axes(ax, width="40%", height="30%", borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+        ins.get_position().extents, [.9-.8*.4, .9-.8*.3, 0.9, 0.9])
+
+    ins = inset_axes(ax, width=1., height=1.2, bbox_to_anchor=(200, 100),
+                     loc=3, borderpad=0)
+    fig.canvas.draw()
+    assert_array_almost_equal(
+        ins.get_position().extents,
+        [200/dpi/figsize[0], 100/dpi/figsize[1],
+         (200/dpi+1)/figsize[0], (100/dpi+1.2)/figsize[1]])
+
+    ins1 = inset_axes(ax, width="35%", height="60%", loc=3, borderpad=1)
+    ins2 = inset_axes(ax, width="100%", height="100%",
+                      bbox_to_anchor=(0, 0, .35, .60),
+                      bbox_transform=ax.transAxes, loc=3, borderpad=1)
+    fig.canvas.draw()
+    assert_array_equal(ins1.get_position().extents,
+                       ins2.get_position().extents)
+
+    with pytest.raises(ValueError):
+        ins = inset_axes(ax, width="40%", height="30%",
+                         bbox_to_anchor=(0.4, 0.5))
+
+    with pytest.warns(UserWarning):
+        ins = inset_axes(ax, width="40%", height="30%",
+                         bbox_transform=ax.transAxes)
+
+
+def test_inset_axes_tight():
+    # gh-26287 found that inset_axes raised with bbox_inches=tight
+    fig, ax = plt.subplots()
+    inset_axes(ax, width=1.3, height=0.9)
+
+    f = io.BytesIO()
+    fig.savefig(f, bbox_inches="tight")
+
+
+@image_comparison(['fill_facecolor.png'], remove_text=True, style='mpl20')
+def test_fill_facecolor():
+    fig, ax = plt.subplots(1, 5)
+    fig.set_size_inches(5, 5)
+    for i in range(1, 4):
+        ax[i].yaxis.set_visible(False)
+    ax[4].yaxis.tick_right()
+    bbox = Bbox.from_extents(0, 0.4, 1, 0.6)
+
+    # fill with blue by setting 'fc' field
+    bbox1 = TransformedBbox(bbox, ax[0].transData)
+    bbox2 = TransformedBbox(bbox, ax[1].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox1, bbox2, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", fc="b")
+    p.set_clip_on(False)
+    ax[0].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[0], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.xaxis.set_ticks([])
+    plt.gca().axes.yaxis.set_ticks([])
+    mark_inset(ax[0], axins, loc1=2, loc2=4, fc="b", ec="0.5")
+
+    # fill with yellow by setting 'facecolor' field
+    bbox3 = TransformedBbox(bbox, ax[1].transData)
+    bbox4 = TransformedBbox(bbox, ax[2].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox3, bbox4, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", facecolor="y")
+    p.set_clip_on(False)
+    ax[1].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[1], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.xaxis.set_ticks([])
+    plt.gca().axes.yaxis.set_ticks([])
+    mark_inset(ax[1], axins, loc1=2, loc2=4, facecolor="y", ec="0.5")
+
+    # fill with green by setting 'color' field
+    bbox5 = TransformedBbox(bbox, ax[2].transData)
+    bbox6 = TransformedBbox(bbox, ax[3].transData)
+    # set color to BboxConnectorPatch
+    p = BboxConnectorPatch(
+        bbox5, bbox6, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", color="g")
+    p.set_clip_on(False)
+    ax[2].add_patch(p)
+    # set color to marked area
+    axins = zoomed_inset_axes(ax[2], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    plt.gca().axes.xaxis.set_ticks([])
+    plt.gca().axes.yaxis.set_ticks([])
+    mark_inset(ax[2], axins, loc1=2, loc2=4, color="g", ec="0.5")
+
+    # fill with green but color won't show if set fill to False
+    bbox7 = TransformedBbox(bbox, ax[3].transData)
+    bbox8 = TransformedBbox(bbox, ax[4].transData)
+    # BboxConnectorPatch won't show green
+    p = BboxConnectorPatch(
+        bbox7, bbox8, loc1a=1, loc2a=2, loc1b=4, loc2b=3,
+        ec="r", fc="g", fill=False)
+    p.set_clip_on(False)
+    ax[3].add_patch(p)
+    # marked area won't show green
+    axins = zoomed_inset_axes(ax[3], 1, loc='upper right')
+    axins.set_xlim(0, 0.2)
+    axins.set_ylim(0, 0.2)
+    axins.xaxis.set_ticks([])
+    axins.yaxis.set_ticks([])
+    mark_inset(ax[3], axins, loc1=2, loc2=4, fc="g", ec="0.5", fill=False)
+
+
+# Update style when regenerating the test image
+@image_comparison(['zoomed_axes.png', 'inverted_zoomed_axes.png'],
+                  style=('classic', '_classic_test_patch'),
+                  tol=0.02 if platform.machine() == 'arm64' else 0)
+def test_zooming_with_inverted_axes():
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 2, 3])
+    ax.axis([1, 3, 1, 3])
+    inset_ax = zoomed_inset_axes(ax, zoom=2.5, loc='lower right')
+    inset_ax.axis([1.1, 1.4, 1.1, 1.4])
+
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 2, 3])
+    ax.axis([3, 1, 3, 1])
+    inset_ax = zoomed_inset_axes(ax, zoom=2.5, loc='lower right')
+    inset_ax.axis([1.4, 1.1, 1.4, 1.1])
+
+
+# Update style when regenerating the test image
+@image_comparison(['anchored_direction_arrows.png'],
+                  tol=0 if platform.machine() == 'x86_64' else 0.01,
+                  style=('classic', '_classic_test_patch'))
+def test_anchored_direction_arrows():
+    fig, ax = plt.subplots()
+    ax.imshow(np.zeros((10, 10)), interpolation='nearest')
+
+    simple_arrow = AnchoredDirectionArrows(ax.transAxes, 'X', 'Y')
+    ax.add_artist(simple_arrow)
+
+
+# Update style when regenerating the test image
+@image_comparison(['anchored_direction_arrows_many_args.png'],
+                  style=('classic', '_classic_test_patch'))
+def test_anchored_direction_arrows_many_args():
+    fig, ax = plt.subplots()
+    ax.imshow(np.ones((10, 10)))
+
+    direction_arrows = AnchoredDirectionArrows(
+            ax.transAxes, 'A', 'B', loc='upper right', color='red',
+            aspect_ratio=-0.5, pad=0.6, borderpad=2, frameon=True, alpha=0.7,
+            sep_x=-0.06, sep_y=-0.08, back_length=0.1, head_width=9,
+            head_length=10, tail_width=5)
+    ax.add_artist(direction_arrows)
+
+
+def test_axes_locatable_position():
+    fig, ax = plt.subplots()
+    divider = make_axes_locatable(ax)
+    with mpl.rc_context({"figure.subplot.wspace": 0.02}):
+        cax = divider.append_axes('right', size='5%')
+    fig.canvas.draw()
+    assert np.isclose(cax.get_position(original=False).width,
+                      0.03621495327102808)
+
+
+@image_comparison(['image_grid_each_left_label_mode_all.png'], style='mpl20',
+                  savefig_kwarg={'bbox_inches': 'tight'})
+def test_image_grid_each_left_label_mode_all():
+    imdata = np.arange(100).reshape((10, 10))
+
+    fig = plt.figure(1, (3, 3))
+    grid = ImageGrid(fig, (1, 1, 1), nrows_ncols=(3, 2), axes_pad=(0.5, 0.3),
+                     cbar_mode="each", cbar_location="left", cbar_size="15%",
+                     label_mode="all")
+    # 3-tuple rect => SubplotDivider
+    assert isinstance(grid.get_divider(), SubplotDivider)
+    assert grid.get_axes_pad() == (0.5, 0.3)
+    assert grid.get_aspect()  # True by default for ImageGrid
+    for ax, cax in zip(grid, grid.cbar_axes):
+        im = ax.imshow(imdata, interpolation='none')
+        cax.colorbar(im)
+
+
+@image_comparison(['image_grid_single_bottom_label_mode_1.png'], style='mpl20',
+                  savefig_kwarg={'bbox_inches': 'tight'})
+def test_image_grid_single_bottom():
+    imdata = np.arange(100).reshape((10, 10))
+
+    fig = plt.figure(1, (2.5, 1.5))
+    grid = ImageGrid(fig, (0, 0, 1, 1), nrows_ncols=(1, 3),
+                     axes_pad=(0.2, 0.15), cbar_mode="single",
+                     cbar_location="bottom", cbar_size="10%", label_mode="1")
+    # 4-tuple rect => Divider, isinstance will give True for SubplotDivider
+    assert type(grid.get_divider()) is Divider
+    for i in range(3):
+        im = grid[i].imshow(imdata, interpolation='none')
+    grid.cbar_axes[0].colorbar(im)
+
+
+def test_image_grid_label_mode_invalid():
+    fig = plt.figure()
+    with pytest.raises(ValueError, match="'foo' is not a valid value for mode"):
+        ImageGrid(fig, (0, 0, 1, 1), (2, 1), label_mode="foo")
+
+
+@image_comparison(['image_grid.png'],
+                  remove_text=True, style='mpl20',
+                  savefig_kwarg={'bbox_inches': 'tight'})
+def test_image_grid():
+    # test that image grid works with bbox_inches=tight.
+    im = np.arange(100).reshape((10, 10))
+
+    fig = plt.figure(1, (4, 4))
+    grid = ImageGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=0.1)
+    assert grid.get_axes_pad() == (0.1, 0.1)
+    for i in range(4):
+        grid[i].imshow(im, interpolation='nearest')
+
+
+def test_gettightbbox():
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    l, = ax.plot([1, 2, 3], [0, 1, 0])
+
+    ax_zoom = zoomed_inset_axes(ax, 4)
+    ax_zoom.plot([1, 2, 3], [0, 1, 0])
+
+    mark_inset(ax, ax_zoom, loc1=1, loc2=3, fc="none", ec='0.3')
+
+    remove_ticks_and_titles(fig)
+    bbox = fig.get_tightbbox(fig.canvas.get_renderer())
+    np.testing.assert_array_almost_equal(bbox.extents,
+                                         [-17.7, -13.9, 7.2, 5.4])
+
+
+@pytest.mark.parametrize("click_on", ["big", "small"])
+@pytest.mark.parametrize("big_on_axes,small_on_axes", [
+    ("gca", "gca"),
+    ("host", "host"),
+    ("host", "parasite"),
+    ("parasite", "host"),
+    ("parasite", "parasite")
+])
+def test_picking_callbacks_overlap(big_on_axes, small_on_axes, click_on):
+    """Test pick events on normal, host or parasite axes."""
+    # Two rectangles are drawn and "clicked on", a small one and a big one
+    # enclosing the small one. The axis on which they are drawn as well as the
+    # rectangle that is clicked on are varied.
+    # In each case we expect that both rectangles are picked if we click on the
+    # small one and only the big one is picked if we click on the big one.
+    # Also tests picking on normal axes ("gca") as a control.
+    big = plt.Rectangle((0.25, 0.25), 0.5, 0.5, picker=5)
+    small = plt.Rectangle((0.4, 0.4), 0.2, 0.2, facecolor="r", picker=5)
+    # Machinery for "receiving" events
+    received_events = []
+    def on_pick(event):
+        received_events.append(event)
+    plt.gcf().canvas.mpl_connect('pick_event', on_pick)
+    # Shortcut
+    rectangles_on_axes = (big_on_axes, small_on_axes)
+    # Axes setup
+    axes = {"gca": None, "host": None, "parasite": None}
+    if "gca" in rectangles_on_axes:
+        axes["gca"] = plt.gca()
+    if "host" in rectangles_on_axes or "parasite" in rectangles_on_axes:
+        axes["host"] = host_subplot(111)
+        axes["parasite"] = axes["host"].twin()
+    # Add rectangles to axes
+    axes[big_on_axes].add_patch(big)
+    axes[small_on_axes].add_patch(small)
+    # Simulate picking with click mouse event
+    if click_on == "big":
+        click_axes = axes[big_on_axes]
+        axes_coords = (0.3, 0.3)
+    else:
+        click_axes = axes[small_on_axes]
+        axes_coords = (0.5, 0.5)
+    # In reality mouse events never happen on parasite axes, only host axes
+    if click_axes is axes["parasite"]:
+        click_axes = axes["host"]
+    (x, y) = click_axes.transAxes.transform(axes_coords)
+    m = MouseEvent("button_press_event", click_axes.figure.canvas, x, y,
+                   button=1)
+    click_axes.pick(m)
+    # Checks
+    expected_n_events = 2 if click_on == "small" else 1
+    assert len(received_events) == expected_n_events
+    event_rects = [event.artist for event in received_events]
+    assert big in event_rects
+    if click_on == "small":
+        assert small in event_rects
+
+
+@image_comparison(['anchored_artists.png'], remove_text=True, style='mpl20')
+def test_anchored_artists():
+    fig, ax = plt.subplots(figsize=(3, 3))
+    ada = AnchoredDrawingArea(40, 20, 0, 0, loc='upper right', pad=0.,
+                              frameon=False)
+    p1 = Circle((10, 10), 10)
+    ada.drawing_area.add_artist(p1)
+    p2 = Circle((30, 10), 5, fc="r")
+    ada.drawing_area.add_artist(p2)
+    ax.add_artist(ada)
+
+    box = AnchoredAuxTransformBox(ax.transData, loc='upper left')
+    el = Ellipse((0, 0), width=0.1, height=0.4, angle=30, color='cyan')
+    box.drawing_area.add_artist(el)
+    ax.add_artist(box)
+
+    # Manually construct the ellipse instead, once the deprecation elapses.
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        ae = AnchoredEllipse(ax.transData, width=0.1, height=0.25, angle=-60,
+                             loc='lower left', pad=0.5, borderpad=0.4,
+                             frameon=True)
+    ax.add_artist(ae)
+
+    asb = AnchoredSizeBar(ax.transData, 0.2, r"0.2 units", loc='lower right',
+                          pad=0.3, borderpad=0.4, sep=4, fill_bar=True,
+                          frameon=False, label_top=True, prop={'size': 20},
+                          size_vertical=0.05, color='green')
+    ax.add_artist(asb)
+
+
+def test_hbox_divider():
+    arr1 = np.arange(20).reshape((4, 5))
+    arr2 = np.arange(20).reshape((5, 4))
+
+    fig, (ax1, ax2) = plt.subplots(1, 2)
+    ax1.imshow(arr1)
+    ax2.imshow(arr2)
+
+    pad = 0.5  # inches.
+    divider = HBoxDivider(
+        fig, 111,  # Position of combined axes.
+        horizontal=[Size.AxesX(ax1), Size.Fixed(pad), Size.AxesX(ax2)],
+        vertical=[Size.AxesY(ax1), Size.Scaled(1), Size.AxesY(ax2)])
+    ax1.set_axes_locator(divider.new_locator(0))
+    ax2.set_axes_locator(divider.new_locator(2))
+
+    fig.canvas.draw()
+    p1 = ax1.get_position()
+    p2 = ax2.get_position()
+    assert p1.height == p2.height
+    assert p2.width / p1.width == pytest.approx((4 / 5) ** 2)
+
+
+def test_vbox_divider():
+    arr1 = np.arange(20).reshape((4, 5))
+    arr2 = np.arange(20).reshape((5, 4))
+
+    fig, (ax1, ax2) = plt.subplots(1, 2)
+    ax1.imshow(arr1)
+    ax2.imshow(arr2)
+
+    pad = 0.5  # inches.
+    divider = VBoxDivider(
+        fig, 111,  # Position of combined axes.
+        horizontal=[Size.AxesX(ax1), Size.Scaled(1), Size.AxesX(ax2)],
+        vertical=[Size.AxesY(ax1), Size.Fixed(pad), Size.AxesY(ax2)])
+    ax1.set_axes_locator(divider.new_locator(0))
+    ax2.set_axes_locator(divider.new_locator(2))
+
+    fig.canvas.draw()
+    p1 = ax1.get_position()
+    p2 = ax2.get_position()
+    assert p1.width == p2.width
+    assert p1.height / p2.height == pytest.approx((4 / 5) ** 2)
+
+
+def test_axes_class_tuple():
+    fig = plt.figure()
+    axes_class = (mpl_toolkits.axes_grid1.mpl_axes.Axes, {})
+    gr = AxesGrid(fig, 111, nrows_ncols=(1, 1), axes_class=axes_class)
+
+
+def test_grid_axes_lists():
+    """Test Grid axes_all, axes_row and axes_column relationship."""
+    fig = plt.figure()
+    grid = Grid(fig, 111, (2, 3), direction="row")
+    assert_array_equal(grid, grid.axes_all)
+    assert_array_equal(grid.axes_row, np.transpose(grid.axes_column))
+    assert_array_equal(grid, np.ravel(grid.axes_row), "row")
+    assert grid.get_geometry() == (2, 3)
+    grid = Grid(fig, 111, (2, 3), direction="column")
+    assert_array_equal(grid, np.ravel(grid.axes_column), "column")
+
+
+@pytest.mark.parametrize('direction', ('row', 'column'))
+def test_grid_axes_position(direction):
+    """Test positioning of the axes in Grid."""
+    fig = plt.figure()
+    grid = Grid(fig, 111, (2, 2), direction=direction)
+    loc = [ax.get_axes_locator() for ax in np.ravel(grid.axes_row)]
+    # Test nx.
+    assert loc[1].args[0] > loc[0].args[0]
+    assert loc[0].args[0] == loc[2].args[0]
+    assert loc[3].args[0] == loc[1].args[0]
+    # Test ny.
+    assert loc[2].args[1] < loc[0].args[1]
+    assert loc[0].args[1] == loc[1].args[1]
+    assert loc[3].args[1] == loc[2].args[1]
+
+
+@pytest.mark.parametrize('rect, ngrids, error, message', (
+    ((1, 1), None, TypeError, "Incorrect rect format"),
+    (111, -1, ValueError, "ngrids must be positive"),
+    (111, 7, ValueError, "ngrids must be positive"),
+))
+def test_grid_errors(rect, ngrids, error, message):
+    fig = plt.figure()
+    with pytest.raises(error, match=message):
+        Grid(fig, rect, (2, 3), ngrids=ngrids)
+
+
+@pytest.mark.parametrize('anchor, error, message', (
+    (None, TypeError, "anchor must be str"),
+    ("CC", ValueError, "'CC' is not a valid value for anchor"),
+    ((1, 1, 1), TypeError, "anchor must be str"),
+))
+def test_divider_errors(anchor, error, message):
+    fig = plt.figure()
+    with pytest.raises(error, match=message):
+        Divider(fig, [0, 0, 1, 1], [Size.Fixed(1)], [Size.Fixed(1)],
+                anchor=anchor)
+
+
+@check_figures_equal(extensions=["png"])
+def test_mark_inset_unstales_viewlim(fig_test, fig_ref):
+    inset, full = fig_test.subplots(1, 2)
+    full.plot([0, 5], [0, 5])
+    inset.set(xlim=(1, 2), ylim=(1, 2))
+    # Check that mark_inset unstales full's viewLim before drawing the marks.
+    mark_inset(full, inset, 1, 4)
+
+    inset, full = fig_ref.subplots(1, 2)
+    full.plot([0, 5], [0, 5])
+    inset.set(xlim=(1, 2), ylim=(1, 2))
+    mark_inset(full, inset, 1, 4)
+    # Manually unstale the full's viewLim.
+    fig_ref.canvas.draw()
+
+
+def test_auto_adjustable():
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1])
+    pad = 0.1
+    make_axes_area_auto_adjustable(ax, pad=pad)
+    fig.canvas.draw()
+    tbb = ax.get_tightbbox()
+    assert tbb.x0 == pytest.approx(pad * fig.dpi)
+    assert tbb.x1 == pytest.approx(fig.bbox.width - pad * fig.dpi)
+    assert tbb.y0 == pytest.approx(pad * fig.dpi)
+    assert tbb.y1 == pytest.approx(fig.bbox.height - pad * fig.dpi)
+
+
+# Update style when regenerating the test image
+@image_comparison(['rgb_axes.png'], remove_text=True,
+                  style=('classic', '_classic_test_patch'))
+def test_rgb_axes():
+    fig = plt.figure()
+    ax = RGBAxes(fig, (0.1, 0.1, 0.8, 0.8), pad=0.1)
+    rng = np.random.default_rng(19680801)
+    r = rng.random((5, 5))
+    g = rng.random((5, 5))
+    b = rng.random((5, 5))
+    ax.imshow_rgb(r, g, b, interpolation='none')
+
+
+# Update style when regenerating the test image
+@image_comparison(['insetposition.png'], remove_text=True,
+                  style=('classic', '_classic_test_patch'))
+def test_insetposition():
+    fig, ax = plt.subplots(figsize=(2, 2))
+    ax_ins = plt.axes([0, 0, 1, 1])
+    with pytest.warns(mpl.MatplotlibDeprecationWarning):
+        ip = InsetPosition(ax, [0.2, 0.25, 0.5, 0.4])
+    ax_ins.set_axes_locator(ip)
+
+
+# The original version of this test relied on mpl_toolkits's slightly different
+# colorbar implementation; moving to matplotlib's own colorbar implementation
+# caused the small image comparison error.
+@image_comparison(['imagegrid_cbar_mode.png'],
+                  remove_text=True, style='mpl20', tol=0.3)
+def test_imagegrid_cbar_mode_edge():
+    arr = np.arange(16).reshape((4, 4))
+
+    fig = plt.figure(figsize=(18, 9))
+
+    positions = (241, 242, 243, 244, 245, 246, 247, 248)
+    directions = ['row']*4 + ['column']*4
+    cbar_locations = ['left', 'right', 'top', 'bottom']*2
+
+    for position, direction, location in zip(
+            positions, directions, cbar_locations):
+        grid = ImageGrid(fig, position,
+                         nrows_ncols=(2, 2),
+                         direction=direction,
+                         cbar_location=location,
+                         cbar_size='20%',
+                         cbar_mode='edge')
+        ax1, ax2, ax3, ax4 = grid
+
+        ax1.imshow(arr, cmap='nipy_spectral')
+        ax2.imshow(arr.T, cmap='hot')
+        ax3.imshow(np.hypot(arr, arr.T), cmap='jet')
+        ax4.imshow(np.arctan2(arr, arr.T), cmap='hsv')
+
+        # In each row/column, the "first" colorbars must be overwritten by the
+        # "second" ones.  To achieve this, clear out the axes first.
+        for ax in grid:
+            ax.cax.cla()
+            cb = ax.cax.colorbar(ax.images[0])
+
+
+def test_imagegrid():
+    fig = plt.figure()
+    grid = ImageGrid(fig, 111, nrows_ncols=(1, 1))
+    ax = grid[0]
+    im = ax.imshow([[1, 2]], norm=mpl.colors.LogNorm())
+    cb = ax.cax.colorbar(im)
+    assert isinstance(cb.locator, mticker.LogLocator)
+
+
+def test_removal():
+    import matplotlib.pyplot as plt
+    import mpl_toolkits.axisartist as AA
+    fig = plt.figure()
+    ax = host_subplot(111, axes_class=AA.Axes, figure=fig)
+    col = ax.fill_between(range(5), 0, range(5))
+    fig.canvas.draw()
+    col.remove()
+    fig.canvas.draw()
+
+
+@image_comparison(['anchored_locator_base_call.png'], style="mpl20")
+def test_anchored_locator_base_call():
+    fig = plt.figure(figsize=(3, 3))
+    fig1, fig2 = fig.subfigures(nrows=2, ncols=1)
+
+    ax = fig1.subplots()
+    ax.set(aspect=1, xlim=(-15, 15), ylim=(-20, 5))
+    ax.set(xticks=[], yticks=[])
+
+    Z = cbook.get_sample_data("axes_grid/bivariate_normal.npy")
+    extent = (-3, 4, -4, 3)
+
+    axins = zoomed_inset_axes(ax, zoom=2, loc="upper left")
+    axins.set(xticks=[], yticks=[])
+
+    axins.imshow(Z, extent=extent, origin="lower")
+
+
+def test_grid_with_axes_class_not_overriding_axis():
+    Grid(plt.figure(), 111, (2, 2), axes_class=mpl.axes.Axes)
+    RGBAxes(plt.figure(), 111, axes_class=mpl.axes.Axes)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f4eb124e1fc0f86340df2b5eb3b2d9b1d40ea3e
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/angle_helper.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/angle_helper.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13f9e57fa69ab34cb7da70f72cbf66224eed0b1c
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/angle_helper.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_divider.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_divider.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..722895e67395fceac91913f29c40125e95ae8c49
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_divider.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_grid.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_grid.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11f4462cd80bbd8ddcd3e97799dd7619433cf06f
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_grid.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_rgb.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_rgb.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b027b0c31a772cdc541c91eacec464aadb4b21a5
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axes_rgb.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axis_artist.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axis_artist.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1406ac9e823e20ee0190419afb7f2c257f13791e
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axis_artist.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axisline_style.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axisline_style.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b10ab835a6c7922d677693ad33df61da147f64ba
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axisline_style.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axislines.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axislines.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9015273b2fc742a7b048b0063ab39b43e07603e5
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/axislines.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/floating_axes.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/floating_axes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d26985a9a309f87afa0e09c85487416b7b48af03
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/floating_axes.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_finder.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_finder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e39da01e092793972934b9161deabfef152465c
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_finder.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_helper_curvelinear.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_helper_curvelinear.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5c187b21821cc29a71eca9b0b277dee7aeba710
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/grid_helper_curvelinear.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/parasite_axes.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/parasite_axes.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5f6ce92bfce46d18f34a25b4dc8aa3eee547da5
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/__pycache__/parasite_axes.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..689ca8087126a4ae7127b1c9cc78c58854fe3136
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/conftest.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1500061801169724519d496ee704f0297aa519c9
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/conftest.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_angle_helper.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_angle_helper.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2068512d3bc98f90c169de27677190c1adfbba6
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_angle_helper.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_axis_artist.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_axis_artist.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e4a5ebdd6aac7cfb4f3e53c2a011b440f958578
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/__pycache__/test_axis_artist.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_floating_axes.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_floating_axes.py
new file mode 100644
index 0000000000000000000000000000000000000000..7644fea1696599273f6214d7735bb919b500108c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_floating_axes.py
@@ -0,0 +1,115 @@
+import numpy as np
+
+import matplotlib.pyplot as plt
+import matplotlib.projections as mprojections
+import matplotlib.transforms as mtransforms
+from matplotlib.testing.decorators import image_comparison
+from mpl_toolkits.axisartist.axislines import Subplot
+from mpl_toolkits.axisartist.floating_axes import (
+    FloatingAxes, GridHelperCurveLinear)
+from mpl_toolkits.axisartist.grid_finder import FixedLocator
+from mpl_toolkits.axisartist import angle_helper
+
+
+def test_subplot():
+    fig = plt.figure(figsize=(5, 5))
+    ax = Subplot(fig, 111)
+    fig.add_subplot(ax)
+
+
+# Rather high tolerance to allow ongoing work with floating axes internals;
+# remove when image is regenerated.
+@image_comparison(['curvelinear3.png'], style='default', tol=5)
+def test_curvelinear3():
+    fig = plt.figure(figsize=(5, 5))
+
+    tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
+          mprojections.PolarAxes.PolarTransform(apply_theta_transforms=False))
+    grid_helper = GridHelperCurveLinear(
+        tr,
+        extremes=(0, 360, 10, 3),
+        grid_locator1=angle_helper.LocatorDMS(15),
+        grid_locator2=FixedLocator([2, 4, 6, 8, 10]),
+        tick_formatter1=angle_helper.FormatterDMS(),
+        tick_formatter2=None)
+    ax1 = fig.add_subplot(axes_class=FloatingAxes, grid_helper=grid_helper)
+
+    r_scale = 10
+    tr2 = mtransforms.Affine2D().scale(1, 1 / r_scale) + tr
+    grid_helper2 = GridHelperCurveLinear(
+        tr2,
+        extremes=(0, 360, 10 * r_scale, 3 * r_scale),
+        grid_locator2=FixedLocator([30, 60, 90]))
+
+    ax1.axis["right"] = axis = grid_helper2.new_fixed_axis("right", axes=ax1)
+
+    ax1.axis["left"].label.set_text("Test 1")
+    ax1.axis["right"].label.set_text("Test 2")
+    ax1.axis["left", "right"].set_visible(False)
+
+    axis = grid_helper.new_floating_axis(1, 7, axes=ax1,
+                                         axis_direction="bottom")
+    ax1.axis["z"] = axis
+    axis.toggle(all=True, label=True)
+    axis.label.set_text("z = ?")
+    axis.label.set_visible(True)
+    axis.line.set_color("0.5")
+
+    ax2 = ax1.get_aux_axes(tr)
+
+    xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
+    ax2.scatter(xx, yy)
+    l, = ax2.plot(xx, yy, "k-")
+    l.set_clip_path(ax1.patch)
+
+
+# Rather high tolerance to allow ongoing work with floating axes internals;
+# remove when image is regenerated.
+@image_comparison(['curvelinear4.png'], style='default', tol=0.9)
+def test_curvelinear4():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure(figsize=(5, 5))
+
+    tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
+          mprojections.PolarAxes.PolarTransform(apply_theta_transforms=False))
+    grid_helper = GridHelperCurveLinear(
+        tr,
+        extremes=(120, 30, 10, 0),
+        grid_locator1=angle_helper.LocatorDMS(5),
+        grid_locator2=FixedLocator([2, 4, 6, 8, 10]),
+        tick_formatter1=angle_helper.FormatterDMS(),
+        tick_formatter2=None)
+    ax1 = fig.add_subplot(axes_class=FloatingAxes, grid_helper=grid_helper)
+    ax1.clear()  # Check that clear() also restores the correct limits on ax1.
+
+    ax1.axis["left"].label.set_text("Test 1")
+    ax1.axis["right"].label.set_text("Test 2")
+    ax1.axis["top"].set_visible(False)
+
+    axis = grid_helper.new_floating_axis(1, 70, axes=ax1,
+                                         axis_direction="bottom")
+    ax1.axis["z"] = axis
+    axis.toggle(all=True, label=True)
+    axis.label.set_axis_direction("top")
+    axis.label.set_text("z = ?")
+    axis.label.set_visible(True)
+    axis.line.set_color("0.5")
+
+    ax2 = ax1.get_aux_axes(tr)
+
+    xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
+    ax2.scatter(xx, yy)
+    l, = ax2.plot(xx, yy, "k-")
+    l.set_clip_path(ax1.patch)
+
+
+def test_axis_direction():
+    # Check that axis direction is propagated on a floating axis
+    fig = plt.figure()
+    ax = Subplot(fig, 111)
+    fig.add_subplot(ax)
+    ax.axis['y'] = ax.new_floating_axis(nth_coord=1, value=0,
+                                        axis_direction='left')
+    assert ax.axis['y']._axis_direction == 'left'
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b266044bdd06d995a1df86779dac97dae8cb13e
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/axisartist/tests/test_grid_helper_curvelinear.py
@@ -0,0 +1,207 @@
+import numpy as np
+
+import matplotlib.pyplot as plt
+from matplotlib.path import Path
+from matplotlib.projections import PolarAxes
+from matplotlib.ticker import FuncFormatter
+from matplotlib.transforms import Affine2D, Transform
+from matplotlib.testing.decorators import image_comparison
+
+from mpl_toolkits.axisartist import SubplotHost
+from mpl_toolkits.axes_grid1.parasite_axes import host_axes_class_factory
+from mpl_toolkits.axisartist import angle_helper
+from mpl_toolkits.axisartist.axislines import Axes
+from mpl_toolkits.axisartist.grid_helper_curvelinear import \
+    GridHelperCurveLinear
+
+
+@image_comparison(['custom_transform.png'], style='default', tol=0.2)
+def test_custom_transform():
+    class MyTransform(Transform):
+        input_dims = output_dims = 2
+
+        def __init__(self, resolution):
+            """
+            Resolution is the number of steps to interpolate between each input
+            line segment to approximate its path in transformed space.
+            """
+            Transform.__init__(self)
+            self._resolution = resolution
+
+        def transform(self, ll):
+            x, y = ll.T
+            return np.column_stack([x, y - x])
+
+        transform_non_affine = transform
+
+        def transform_path(self, path):
+            ipath = path.interpolated(self._resolution)
+            return Path(self.transform(ipath.vertices), ipath.codes)
+
+        transform_path_non_affine = transform_path
+
+        def inverted(self):
+            return MyTransformInv(self._resolution)
+
+    class MyTransformInv(Transform):
+        input_dims = output_dims = 2
+
+        def __init__(self, resolution):
+            Transform.__init__(self)
+            self._resolution = resolution
+
+        def transform(self, ll):
+            x, y = ll.T
+            return np.column_stack([x, y + x])
+
+        def inverted(self):
+            return MyTransform(self._resolution)
+
+    fig = plt.figure()
+
+    SubplotHost = host_axes_class_factory(Axes)
+
+    tr = MyTransform(1)
+    grid_helper = GridHelperCurveLinear(tr)
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+    fig.add_subplot(ax1)
+
+    ax2 = ax1.get_aux_axes(tr, viewlim_mode="equal")
+    ax2.plot([3, 6], [5.0, 10.])
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(0, 10)
+    ax1.set_ylim(0, 10)
+
+    ax1.grid(True)
+
+
+@image_comparison(['polar_box.png'], style='default', tol=0.04)
+def test_polar_box():
+    fig = plt.figure(figsize=(5, 5))
+
+    # PolarAxes.PolarTransform takes radian. However, we want our coordinate
+    # system in degree
+    tr = (Affine2D().scale(np.pi / 180., 1.) +
+          PolarAxes.PolarTransform(apply_theta_transforms=False))
+
+    # polar projection, which involves cycle, and also has limits in
+    # its coordinates, needs a special method to find the extremes
+    # (min, max of the coordinate within the view).
+    extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
+                                                     lon_cycle=360,
+                                                     lat_cycle=None,
+                                                     lon_minmax=None,
+                                                     lat_minmax=(0, np.inf))
+
+    grid_helper = GridHelperCurveLinear(
+        tr,
+        extreme_finder=extreme_finder,
+        grid_locator1=angle_helper.LocatorDMS(12),
+        tick_formatter1=angle_helper.FormatterDMS(),
+        tick_formatter2=FuncFormatter(lambda x, p: "eight" if x == 8 else f"{int(x)}"),
+    )
+
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+
+    ax1.axis["right"].major_ticklabels.set_visible(True)
+    ax1.axis["top"].major_ticklabels.set_visible(True)
+
+    # let right axis shows ticklabels for 1st coordinate (angle)
+    ax1.axis["right"].get_helper().nth_coord_ticks = 0
+    # let bottom axis shows ticklabels for 2nd coordinate (radius)
+    ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
+
+    fig.add_subplot(ax1)
+
+    ax1.axis["lat"] = axis = grid_helper.new_floating_axis(0, 45, axes=ax1)
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper().set_extremes(2, 12)
+
+    ax1.axis["lon"] = axis = grid_helper.new_floating_axis(1, 6, axes=ax1)
+    axis.label.set_text("Test 2")
+    axis.get_helper().set_extremes(-180, 90)
+
+    # A parasite axes with given transform
+    ax2 = ax1.get_aux_axes(tr, viewlim_mode="equal")
+    assert ax2.transData == tr + ax1.transData
+    # Anything you draw in ax2 will match the ticks and grids of ax1.
+    ax2.plot(np.linspace(0, 30, 50), np.linspace(10, 10, 50))
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(-5, 12)
+    ax1.set_ylim(-5, 10)
+
+    ax1.grid(True)
+
+
+# Remove tol & kerning_factor when this test image is regenerated.
+@image_comparison(['axis_direction.png'], style='default', tol=0.13)
+def test_axis_direction():
+    plt.rcParams['text.kerning_factor'] = 6
+
+    fig = plt.figure(figsize=(5, 5))
+
+    # PolarAxes.PolarTransform takes radian. However, we want our coordinate
+    # system in degree
+    tr = (Affine2D().scale(np.pi / 180., 1.) +
+          PolarAxes.PolarTransform(apply_theta_transforms=False))
+
+    # polar projection, which involves cycle, and also has limits in
+    # its coordinates, needs a special method to find the extremes
+    # (min, max of the coordinate within the view).
+
+    # 20, 20 : number of sampling points along x, y direction
+    extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
+                                                     lon_cycle=360,
+                                                     lat_cycle=None,
+                                                     lon_minmax=None,
+                                                     lat_minmax=(0, np.inf),
+                                                     )
+
+    grid_locator1 = angle_helper.LocatorDMS(12)
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_helper = GridHelperCurveLinear(tr,
+                                        extreme_finder=extreme_finder,
+                                        grid_locator1=grid_locator1,
+                                        tick_formatter1=tick_formatter1)
+
+    ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
+
+    for axis in ax1.axis.values():
+        axis.set_visible(False)
+
+    fig.add_subplot(ax1)
+
+    ax1.axis["lat1"] = axis = grid_helper.new_floating_axis(
+        0, 130,
+        axes=ax1, axis_direction="left")
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper().set_extremes(0.001, 10)
+
+    ax1.axis["lat2"] = axis = grid_helper.new_floating_axis(
+        0, 50,
+        axes=ax1, axis_direction="right")
+    axis.label.set_text("Test")
+    axis.label.set_visible(True)
+    axis.get_helper().set_extremes(0.001, 10)
+
+    ax1.axis["lon"] = axis = grid_helper.new_floating_axis(
+        1, 10,
+        axes=ax1, axis_direction="bottom")
+    axis.label.set_text("Test 2")
+    axis.get_helper().set_extremes(50, 130)
+    axis.major_ticklabels.set_axis_direction("top")
+    axis.label.set_axis_direction("top")
+
+    grid_helper.grid_finder.grid_locator1.set_params(nbins=5)
+    grid_helper.grid_finder.grid_locator2.set_params(nbins=5)
+
+    ax1.set_aspect(1.)
+    ax1.set_xlim(-8, 8)
+    ax1.set_ylim(-4, 12)
+
+    ax1.grid(True)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__init__.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a089fbd6b70ebdafb19f6c902d49e5e3bdc05f43
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__init__.py
@@ -0,0 +1,3 @@
+from .axes3d import Axes3D
+
+__all__ = ['Axes3D']
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbc85c5fa4c9057c400ec8020c3cbd6957fde7fe
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/art3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/art3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..741edca62e4c2ec7caed80d13fcc453600a70036
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/art3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/axis3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/axis3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a9b745cfd028c61af7339fbecf4514f48dfefd2
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/axis3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/proj3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/proj3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4142658c3814e3a9c8ce8ae62fcb3ec884ac2160
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/__pycache__/proj3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/art3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/art3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..44585ccd05e79b027181df9dd58f357207d93f5c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/art3d.py
@@ -0,0 +1,1262 @@
+# art3d.py, original mplot3d version by John Porter
+# Parts rewritten by Reinier Heeres <reinier@heeres.eu>
+# Minor additions by Ben Axelrod <baxelrod@coroware.com>
+
+"""
+Module containing 3D artist code and functions to convert 2D
+artists into 3D versions which can be added to an Axes3D.
+"""
+
+import math
+
+import numpy as np
+
+from contextlib import contextmanager
+
+from matplotlib import (
+    artist, cbook, colors as mcolors, lines, text as mtext,
+    path as mpath)
+from matplotlib.collections import (
+    Collection, LineCollection, PolyCollection, PatchCollection, PathCollection)
+from matplotlib.colors import Normalize
+from matplotlib.patches import Patch
+from . import proj3d
+
+
+def _norm_angle(a):
+    """Return the given angle normalized to -180 < *a* <= 180 degrees."""
+    a = (a + 360) % 360
+    if a > 180:
+        a = a - 360
+    return a
+
+
+def _norm_text_angle(a):
+    """Return the given angle normalized to -90 < *a* <= 90 degrees."""
+    a = (a + 180) % 180
+    if a > 90:
+        a = a - 180
+    return a
+
+
+def get_dir_vector(zdir):
+    """
+    Return a direction vector.
+
+    Parameters
+    ----------
+    zdir : {'x', 'y', 'z', None, 3-tuple}
+        The direction. Possible values are:
+
+        - 'x': equivalent to (1, 0, 0)
+        - 'y': equivalent to (0, 1, 0)
+        - 'z': equivalent to (0, 0, 1)
+        - *None*: equivalent to (0, 0, 0)
+        - an iterable (x, y, z) is converted to an array
+
+    Returns
+    -------
+    x, y, z : array
+        The direction vector.
+    """
+    if zdir == 'x':
+        return np.array((1, 0, 0))
+    elif zdir == 'y':
+        return np.array((0, 1, 0))
+    elif zdir == 'z':
+        return np.array((0, 0, 1))
+    elif zdir is None:
+        return np.array((0, 0, 0))
+    elif np.iterable(zdir) and len(zdir) == 3:
+        return np.array(zdir)
+    else:
+        raise ValueError("'x', 'y', 'z', None or vector of length 3 expected")
+
+
+class Text3D(mtext.Text):
+    """
+    Text object with 3D position and direction.
+
+    Parameters
+    ----------
+    x, y, z : float
+        The position of the text.
+    text : str
+        The text string to display.
+    zdir : {'x', 'y', 'z', None, 3-tuple}
+        The direction of the text. See `.get_dir_vector` for a description of
+        the values.
+
+    Other Parameters
+    ----------------
+    **kwargs
+         All other parameters are passed on to `~matplotlib.text.Text`.
+    """
+
+    def __init__(self, x=0, y=0, z=0, text='', zdir='z', **kwargs):
+        mtext.Text.__init__(self, x, y, text, **kwargs)
+        self.set_3d_properties(z, zdir)
+
+    def get_position_3d(self):
+        """Return the (x, y, z) position of the text."""
+        return self._x, self._y, self._z
+
+    def set_position_3d(self, xyz, zdir=None):
+        """
+        Set the (*x*, *y*, *z*) position of the text.
+
+        Parameters
+        ----------
+        xyz : (float, float, float)
+            The position in 3D space.
+        zdir : {'x', 'y', 'z', None, 3-tuple}
+            The direction of the text. If unspecified, the *zdir* will not be
+            changed. See `.get_dir_vector` for a description of the values.
+        """
+        super().set_position(xyz[:2])
+        self.set_z(xyz[2])
+        if zdir is not None:
+            self._dir_vec = get_dir_vector(zdir)
+
+    def set_z(self, z):
+        """
+        Set the *z* position of the text.
+
+        Parameters
+        ----------
+        z : float
+        """
+        self._z = z
+        self.stale = True
+
+    def set_3d_properties(self, z=0, zdir='z'):
+        """
+        Set the *z* position and direction of the text.
+
+        Parameters
+        ----------
+        z : float
+            The z-position in 3D space.
+        zdir : {'x', 'y', 'z', 3-tuple}
+            The direction of the text. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        self._z = z
+        self._dir_vec = get_dir_vector(zdir)
+        self.stale = True
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        position3d = np.array((self._x, self._y, self._z))
+        proj = proj3d._proj_trans_points(
+            [position3d, position3d + self._dir_vec], self.axes.M)
+        dx = proj[0][1] - proj[0][0]
+        dy = proj[1][1] - proj[1][0]
+        angle = math.degrees(math.atan2(dy, dx))
+        with cbook._setattr_cm(self, _x=proj[0][0], _y=proj[1][0],
+                               _rotation=_norm_text_angle(angle)):
+            mtext.Text.draw(self, renderer)
+        self.stale = False
+
+    def get_tightbbox(self, renderer=None):
+        # Overwriting the 2d Text behavior which is not valid for 3d.
+        # For now, just return None to exclude from layout calculation.
+        return None
+
+
+def text_2d_to_3d(obj, z=0, zdir='z'):
+    """
+    Convert a `.Text` to a `.Text3D` object.
+
+    Parameters
+    ----------
+    z : float
+        The z-position in 3D space.
+    zdir : {'x', 'y', 'z', 3-tuple}
+        The direction of the text. Default: 'z'.
+        See `.get_dir_vector` for a description of the values.
+    """
+    obj.__class__ = Text3D
+    obj.set_3d_properties(z, zdir)
+
+
+class Line3D(lines.Line2D):
+    """
+    3D line object.
+
+    .. note:: Use `get_data_3d` to obtain the data associated with the line.
+            `~.Line2D.get_data`, `~.Line2D.get_xdata`, and `~.Line2D.get_ydata` return
+            the x- and y-coordinates of the projected 2D-line, not the x- and y-data of
+            the 3D-line. Similarly, use `set_data_3d` to set the data, not
+            `~.Line2D.set_data`, `~.Line2D.set_xdata`, and `~.Line2D.set_ydata`.
+    """
+
+    def __init__(self, xs, ys, zs, *args, **kwargs):
+        """
+
+        Parameters
+        ----------
+        xs : array-like
+            The x-data to be plotted.
+        ys : array-like
+            The y-data to be plotted.
+        zs : array-like
+            The z-data to be plotted.
+        *args, **kwargs
+            Additional arguments are passed to `~matplotlib.lines.Line2D`.
+        """
+        super().__init__([], [], *args, **kwargs)
+        self.set_data_3d(xs, ys, zs)
+
+    def set_3d_properties(self, zs=0, zdir='z'):
+        """
+        Set the *z* position and direction of the line.
+
+        Parameters
+        ----------
+        zs : float or array of floats
+            The location along the *zdir* axis in 3D space to position the
+            line.
+        zdir : {'x', 'y', 'z'}
+            Plane to plot line orthogonal to. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        xs = self.get_xdata()
+        ys = self.get_ydata()
+        zs = cbook._to_unmasked_float_array(zs).ravel()
+        zs = np.broadcast_to(zs, len(xs))
+        self._verts3d = juggle_axes(xs, ys, zs, zdir)
+        self.stale = True
+
+    def set_data_3d(self, *args):
+        """
+        Set the x, y and z data
+
+        Parameters
+        ----------
+        x : array-like
+            The x-data to be plotted.
+        y : array-like
+            The y-data to be plotted.
+        z : array-like
+            The z-data to be plotted.
+
+        Notes
+        -----
+        Accepts x, y, z arguments or a single array-like (x, y, z)
+        """
+        if len(args) == 1:
+            args = args[0]
+        for name, xyz in zip('xyz', args):
+            if not np.iterable(xyz):
+                raise RuntimeError(f'{name} must be a sequence')
+        self._verts3d = args
+        self.stale = True
+
+    def get_data_3d(self):
+        """
+        Get the current data
+
+        Returns
+        -------
+        verts3d : length-3 tuple or array-like
+            The current data as a tuple or array-like.
+        """
+        return self._verts3d
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        xs3d, ys3d, zs3d = self._verts3d
+        xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
+        self.set_data(xs, ys)
+        super().draw(renderer)
+        self.stale = False
+
+
+def line_2d_to_3d(line, zs=0, zdir='z'):
+    """
+    Convert a `.Line2D` to a `.Line3D` object.
+
+    Parameters
+    ----------
+    zs : float
+        The location along the *zdir* axis in 3D space to position the line.
+    zdir : {'x', 'y', 'z'}
+        Plane to plot line orthogonal to. Default: 'z'.
+        See `.get_dir_vector` for a description of the values.
+    """
+
+    line.__class__ = Line3D
+    line.set_3d_properties(zs, zdir)
+
+
+def _path_to_3d_segment(path, zs=0, zdir='z'):
+    """Convert a path to a 3D segment."""
+
+    zs = np.broadcast_to(zs, len(path))
+    pathsegs = path.iter_segments(simplify=False, curves=False)
+    seg = [(x, y, z) for (((x, y), code), z) in zip(pathsegs, zs)]
+    seg3d = [juggle_axes(x, y, z, zdir) for (x, y, z) in seg]
+    return seg3d
+
+
+def _paths_to_3d_segments(paths, zs=0, zdir='z'):
+    """Convert paths from a collection object to 3D segments."""
+
+    if not np.iterable(zs):
+        zs = np.broadcast_to(zs, len(paths))
+    else:
+        if len(zs) != len(paths):
+            raise ValueError('Number of z-coordinates does not match paths.')
+
+    segs = [_path_to_3d_segment(path, pathz, zdir)
+            for path, pathz in zip(paths, zs)]
+    return segs
+
+
+def _path_to_3d_segment_with_codes(path, zs=0, zdir='z'):
+    """Convert a path to a 3D segment with path codes."""
+
+    zs = np.broadcast_to(zs, len(path))
+    pathsegs = path.iter_segments(simplify=False, curves=False)
+    seg_codes = [((x, y, z), code) for ((x, y), code), z in zip(pathsegs, zs)]
+    if seg_codes:
+        seg, codes = zip(*seg_codes)
+        seg3d = [juggle_axes(x, y, z, zdir) for (x, y, z) in seg]
+    else:
+        seg3d = []
+        codes = []
+    return seg3d, list(codes)
+
+
+def _paths_to_3d_segments_with_codes(paths, zs=0, zdir='z'):
+    """
+    Convert paths from a collection object to 3D segments with path codes.
+    """
+
+    zs = np.broadcast_to(zs, len(paths))
+    segments_codes = [_path_to_3d_segment_with_codes(path, pathz, zdir)
+                      for path, pathz in zip(paths, zs)]
+    if segments_codes:
+        segments, codes = zip(*segments_codes)
+    else:
+        segments, codes = [], []
+    return list(segments), list(codes)
+
+
+class Collection3D(Collection):
+    """A collection of 3D paths."""
+
+    def do_3d_projection(self):
+        """Project the points according to renderer matrix."""
+        xyzs_list = [proj3d.proj_transform(*vs.T, self.axes.M)
+                     for vs, _ in self._3dverts_codes]
+        self._paths = [mpath.Path(np.column_stack([xs, ys]), cs)
+                       for (xs, ys, _), (_, cs) in zip(xyzs_list, self._3dverts_codes)]
+        zs = np.concatenate([zs for _, _, zs in xyzs_list])
+        return zs.min() if len(zs) else 1e9
+
+
+def collection_2d_to_3d(col, zs=0, zdir='z'):
+    """Convert a `.Collection` to a `.Collection3D` object."""
+    zs = np.broadcast_to(zs, len(col.get_paths()))
+    col._3dverts_codes = [
+        (np.column_stack(juggle_axes(
+            *np.column_stack([p.vertices, np.broadcast_to(z, len(p.vertices))]).T,
+            zdir)),
+         p.codes)
+        for p, z in zip(col.get_paths(), zs)]
+    col.__class__ = cbook._make_class_factory(Collection3D, "{}3D")(type(col))
+
+
+class Line3DCollection(LineCollection):
+    """
+    A collection of 3D lines.
+    """
+
+    def set_sort_zpos(self, val):
+        """Set the position to use for z-sorting."""
+        self._sort_zpos = val
+        self.stale = True
+
+    def set_segments(self, segments):
+        """
+        Set 3D segments.
+        """
+        self._segments3d = segments
+        super().set_segments([])
+
+    def do_3d_projection(self):
+        """
+        Project the points according to renderer matrix.
+        """
+        xyslist = [proj3d._proj_trans_points(points, self.axes.M)
+                   for points in self._segments3d]
+        segments_2d = [np.column_stack([xs, ys]) for xs, ys, zs in xyslist]
+        LineCollection.set_segments(self, segments_2d)
+
+        # FIXME
+        minz = 1e9
+        for xs, ys, zs in xyslist:
+            minz = min(minz, min(zs))
+        return minz
+
+
+def line_collection_2d_to_3d(col, zs=0, zdir='z'):
+    """Convert a `.LineCollection` to a `.Line3DCollection` object."""
+    segments3d = _paths_to_3d_segments(col.get_paths(), zs, zdir)
+    col.__class__ = Line3DCollection
+    col.set_segments(segments3d)
+
+
+class Patch3D(Patch):
+    """
+    3D patch object.
+    """
+
+    def __init__(self, *args, zs=(), zdir='z', **kwargs):
+        """
+        Parameters
+        ----------
+        verts :
+        zs : float
+            The location along the *zdir* axis in 3D space to position the
+            patch.
+        zdir : {'x', 'y', 'z'}
+            Plane to plot patch orthogonal to. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        super().__init__(*args, **kwargs)
+        self.set_3d_properties(zs, zdir)
+
+    def set_3d_properties(self, verts, zs=0, zdir='z'):
+        """
+        Set the *z* position and direction of the patch.
+
+        Parameters
+        ----------
+        verts :
+        zs : float
+            The location along the *zdir* axis in 3D space to position the
+            patch.
+        zdir : {'x', 'y', 'z'}
+            Plane to plot patch orthogonal to. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        zs = np.broadcast_to(zs, len(verts))
+        self._segment3d = [juggle_axes(x, y, z, zdir)
+                           for ((x, y), z) in zip(verts, zs)]
+
+    def get_path(self):
+        # docstring inherited
+        # self._path2d is not initialized until do_3d_projection
+        if not hasattr(self, '_path2d'):
+            self.axes.M = self.axes.get_proj()
+            self.do_3d_projection()
+        return self._path2d
+
+    def do_3d_projection(self):
+        s = self._segment3d
+        xs, ys, zs = zip(*s)
+        vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
+                                                        self.axes.M)
+        self._path2d = mpath.Path(np.column_stack([vxs, vys]))
+        return min(vzs)
+
+
+class PathPatch3D(Patch3D):
+    """
+    3D PathPatch object.
+    """
+
+    def __init__(self, path, *, zs=(), zdir='z', **kwargs):
+        """
+        Parameters
+        ----------
+        path :
+        zs : float
+            The location along the *zdir* axis in 3D space to position the
+            path patch.
+        zdir : {'x', 'y', 'z', 3-tuple}
+            Plane to plot path patch orthogonal to. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        # Not super().__init__!
+        Patch.__init__(self, **kwargs)
+        self.set_3d_properties(path, zs, zdir)
+
+    def set_3d_properties(self, path, zs=0, zdir='z'):
+        """
+        Set the *z* position and direction of the path patch.
+
+        Parameters
+        ----------
+        path :
+        zs : float
+            The location along the *zdir* axis in 3D space to position the
+            path patch.
+        zdir : {'x', 'y', 'z', 3-tuple}
+            Plane to plot path patch orthogonal to. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        """
+        Patch3D.set_3d_properties(self, path.vertices, zs=zs, zdir=zdir)
+        self._code3d = path.codes
+
+    def do_3d_projection(self):
+        s = self._segment3d
+        xs, ys, zs = zip(*s)
+        vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
+                                                        self.axes.M)
+        self._path2d = mpath.Path(np.column_stack([vxs, vys]), self._code3d)
+        return min(vzs)
+
+
+def _get_patch_verts(patch):
+    """Return a list of vertices for the path of a patch."""
+    trans = patch.get_patch_transform()
+    path = patch.get_path()
+    polygons = path.to_polygons(trans)
+    return polygons[0] if len(polygons) else np.array([])
+
+
+def patch_2d_to_3d(patch, z=0, zdir='z'):
+    """Convert a `.Patch` to a `.Patch3D` object."""
+    verts = _get_patch_verts(patch)
+    patch.__class__ = Patch3D
+    patch.set_3d_properties(verts, z, zdir)
+
+
+def pathpatch_2d_to_3d(pathpatch, z=0, zdir='z'):
+    """Convert a `.PathPatch` to a `.PathPatch3D` object."""
+    path = pathpatch.get_path()
+    trans = pathpatch.get_patch_transform()
+
+    mpath = trans.transform_path(path)
+    pathpatch.__class__ = PathPatch3D
+    pathpatch.set_3d_properties(mpath, z, zdir)
+
+
+class Patch3DCollection(PatchCollection):
+    """
+    A collection of 3D patches.
+    """
+
+    def __init__(self, *args, zs=0, zdir='z', depthshade=True, **kwargs):
+        """
+        Create a collection of flat 3D patches with its normal vector
+        pointed in *zdir* direction, and located at *zs* on the *zdir*
+        axis. 'zs' can be a scalar or an array-like of the same length as
+        the number of patches in the collection.
+
+        Constructor arguments are the same as for
+        :class:`~matplotlib.collections.PatchCollection`. In addition,
+        keywords *zs=0* and *zdir='z'* are available.
+
+        Also, the keyword argument *depthshade* is available to indicate
+        whether to shade the patches in order to give the appearance of depth
+        (default is *True*). This is typically desired in scatter plots.
+        """
+        self._depthshade = depthshade
+        super().__init__(*args, **kwargs)
+        self.set_3d_properties(zs, zdir)
+
+    def get_depthshade(self):
+        return self._depthshade
+
+    def set_depthshade(self, depthshade):
+        """
+        Set whether depth shading is performed on collection members.
+
+        Parameters
+        ----------
+        depthshade : bool
+            Whether to shade the patches in order to give the appearance of
+            depth.
+        """
+        self._depthshade = depthshade
+        self.stale = True
+
+    def set_sort_zpos(self, val):
+        """Set the position to use for z-sorting."""
+        self._sort_zpos = val
+        self.stale = True
+
+    def set_3d_properties(self, zs, zdir):
+        """
+        Set the *z* positions and direction of the patches.
+
+        Parameters
+        ----------
+        zs : float or array of floats
+            The location or locations to place the patches in the collection
+            along the *zdir* axis.
+        zdir : {'x', 'y', 'z'}
+            Plane to plot patches orthogonal to.
+            All patches must have the same direction.
+            See `.get_dir_vector` for a description of the values.
+        """
+        # Force the collection to initialize the face and edgecolors
+        # just in case it is a scalarmappable with a colormap.
+        self.update_scalarmappable()
+        offsets = self.get_offsets()
+        if len(offsets) > 0:
+            xs, ys = offsets.T
+        else:
+            xs = []
+            ys = []
+        self._offsets3d = juggle_axes(xs, ys, np.atleast_1d(zs), zdir)
+        self._z_markers_idx = slice(-1)
+        self._vzs = None
+        self.stale = True
+
+    def do_3d_projection(self):
+        xs, ys, zs = self._offsets3d
+        vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
+                                                        self.axes.M)
+        self._vzs = vzs
+        super().set_offsets(np.column_stack([vxs, vys]))
+
+        if vzs.size > 0:
+            return min(vzs)
+        else:
+            return np.nan
+
+    def _maybe_depth_shade_and_sort_colors(self, color_array):
+        color_array = (
+            _zalpha(color_array, self._vzs)
+            if self._vzs is not None and self._depthshade
+            else color_array
+        )
+        if len(color_array) > 1:
+            color_array = color_array[self._z_markers_idx]
+        return mcolors.to_rgba_array(color_array, self._alpha)
+
+    def get_facecolor(self):
+        return self._maybe_depth_shade_and_sort_colors(super().get_facecolor())
+
+    def get_edgecolor(self):
+        # We need this check here to make sure we do not double-apply the depth
+        # based alpha shading when the edge color is "face" which means the
+        # edge colour should be identical to the face colour.
+        if cbook._str_equal(self._edgecolors, 'face'):
+            return self.get_facecolor()
+        return self._maybe_depth_shade_and_sort_colors(super().get_edgecolor())
+
+
+class Path3DCollection(PathCollection):
+    """
+    A collection of 3D paths.
+    """
+
+    def __init__(self, *args, zs=0, zdir='z', depthshade=True, **kwargs):
+        """
+        Create a collection of flat 3D paths with its normal vector
+        pointed in *zdir* direction, and located at *zs* on the *zdir*
+        axis. 'zs' can be a scalar or an array-like of the same length as
+        the number of paths in the collection.
+
+        Constructor arguments are the same as for
+        :class:`~matplotlib.collections.PathCollection`. In addition,
+        keywords *zs=0* and *zdir='z'* are available.
+
+        Also, the keyword argument *depthshade* is available to indicate
+        whether to shade the patches in order to give the appearance of depth
+        (default is *True*). This is typically desired in scatter plots.
+        """
+        self._depthshade = depthshade
+        self._in_draw = False
+        super().__init__(*args, **kwargs)
+        self.set_3d_properties(zs, zdir)
+        self._offset_zordered = None
+
+    def draw(self, renderer):
+        with self._use_zordered_offset():
+            with cbook._setattr_cm(self, _in_draw=True):
+                super().draw(renderer)
+
+    def set_sort_zpos(self, val):
+        """Set the position to use for z-sorting."""
+        self._sort_zpos = val
+        self.stale = True
+
+    def set_3d_properties(self, zs, zdir):
+        """
+        Set the *z* positions and direction of the paths.
+
+        Parameters
+        ----------
+        zs : float or array of floats
+            The location or locations to place the paths in the collection
+            along the *zdir* axis.
+        zdir : {'x', 'y', 'z'}
+            Plane to plot paths orthogonal to.
+            All paths must have the same direction.
+            See `.get_dir_vector` for a description of the values.
+        """
+        # Force the collection to initialize the face and edgecolors
+        # just in case it is a scalarmappable with a colormap.
+        self.update_scalarmappable()
+        offsets = self.get_offsets()
+        if len(offsets) > 0:
+            xs, ys = offsets.T
+        else:
+            xs = []
+            ys = []
+        self._offsets3d = juggle_axes(xs, ys, np.atleast_1d(zs), zdir)
+        # In the base draw methods we access the attributes directly which
+        # means we cannot resolve the shuffling in the getter methods like
+        # we do for the edge and face colors.
+        #
+        # This means we need to carry around a cache of the unsorted sizes and
+        # widths (postfixed with 3d) and in `do_3d_projection` set the
+        # depth-sorted version of that data into the private state used by the
+        # base collection class in its draw method.
+        #
+        # Grab the current sizes and linewidths to preserve them.
+        self._sizes3d = self._sizes
+        self._linewidths3d = np.array(self._linewidths)
+        xs, ys, zs = self._offsets3d
+
+        # Sort the points based on z coordinates
+        # Performance optimization: Create a sorted index array and reorder
+        # points and point properties according to the index array
+        self._z_markers_idx = slice(-1)
+        self._vzs = None
+        self.stale = True
+
+    def set_sizes(self, sizes, dpi=72.0):
+        super().set_sizes(sizes, dpi)
+        if not self._in_draw:
+            self._sizes3d = sizes
+
+    def set_linewidth(self, lw):
+        super().set_linewidth(lw)
+        if not self._in_draw:
+            self._linewidths3d = np.array(self._linewidths)
+
+    def get_depthshade(self):
+        return self._depthshade
+
+    def set_depthshade(self, depthshade):
+        """
+        Set whether depth shading is performed on collection members.
+
+        Parameters
+        ----------
+        depthshade : bool
+            Whether to shade the patches in order to give the appearance of
+            depth.
+        """
+        self._depthshade = depthshade
+        self.stale = True
+
+    def do_3d_projection(self):
+        xs, ys, zs = self._offsets3d
+        vxs, vys, vzs, vis = proj3d.proj_transform_clip(xs, ys, zs,
+                                                        self.axes.M)
+        # Sort the points based on z coordinates
+        # Performance optimization: Create a sorted index array and reorder
+        # points and point properties according to the index array
+        z_markers_idx = self._z_markers_idx = np.argsort(vzs)[::-1]
+        self._vzs = vzs
+
+        # we have to special case the sizes because of code in collections.py
+        # as the draw method does
+        #      self.set_sizes(self._sizes, self.figure.dpi)
+        # so we cannot rely on doing the sorting on the way out via get_*
+
+        if len(self._sizes3d) > 1:
+            self._sizes = self._sizes3d[z_markers_idx]
+
+        if len(self._linewidths3d) > 1:
+            self._linewidths = self._linewidths3d[z_markers_idx]
+
+        PathCollection.set_offsets(self, np.column_stack((vxs, vys)))
+
+        # Re-order items
+        vzs = vzs[z_markers_idx]
+        vxs = vxs[z_markers_idx]
+        vys = vys[z_markers_idx]
+
+        # Store ordered offset for drawing purpose
+        self._offset_zordered = np.column_stack((vxs, vys))
+
+        return np.min(vzs) if vzs.size else np.nan
+
+    @contextmanager
+    def _use_zordered_offset(self):
+        if self._offset_zordered is None:
+            # Do nothing
+            yield
+        else:
+            # Swap offset with z-ordered offset
+            old_offset = self._offsets
+            super().set_offsets(self._offset_zordered)
+            try:
+                yield
+            finally:
+                self._offsets = old_offset
+
+    def _maybe_depth_shade_and_sort_colors(self, color_array):
+        color_array = (
+            _zalpha(color_array, self._vzs)
+            if self._vzs is not None and self._depthshade
+            else color_array
+        )
+        if len(color_array) > 1:
+            color_array = color_array[self._z_markers_idx]
+        return mcolors.to_rgba_array(color_array, self._alpha)
+
+    def get_facecolor(self):
+        return self._maybe_depth_shade_and_sort_colors(super().get_facecolor())
+
+    def get_edgecolor(self):
+        # We need this check here to make sure we do not double-apply the depth
+        # based alpha shading when the edge color is "face" which means the
+        # edge colour should be identical to the face colour.
+        if cbook._str_equal(self._edgecolors, 'face'):
+            return self.get_facecolor()
+        return self._maybe_depth_shade_and_sort_colors(super().get_edgecolor())
+
+
+def patch_collection_2d_to_3d(col, zs=0, zdir='z', depthshade=True):
+    """
+    Convert a `.PatchCollection` into a `.Patch3DCollection` object
+    (or a `.PathCollection` into a `.Path3DCollection` object).
+
+    Parameters
+    ----------
+    col : `~matplotlib.collections.PatchCollection` or \
+`~matplotlib.collections.PathCollection`
+        The collection to convert.
+    zs : float or array of floats
+        The location or locations to place the patches in the collection along
+        the *zdir* axis. Default: 0.
+    zdir : {'x', 'y', 'z'}
+        The axis in which to place the patches. Default: "z".
+        See `.get_dir_vector` for a description of the values.
+    depthshade : bool, default: True
+        Whether to shade the patches to give a sense of depth.
+
+    """
+    if isinstance(col, PathCollection):
+        col.__class__ = Path3DCollection
+        col._offset_zordered = None
+    elif isinstance(col, PatchCollection):
+        col.__class__ = Patch3DCollection
+    col._depthshade = depthshade
+    col._in_draw = False
+    col.set_3d_properties(zs, zdir)
+
+
+class Poly3DCollection(PolyCollection):
+    """
+    A collection of 3D polygons.
+
+    .. note::
+        **Filling of 3D polygons**
+
+        There is no simple definition of the enclosed surface of a 3D polygon
+        unless the polygon is planar.
+
+        In practice, Matplotlib fills the 2D projection of the polygon. This
+        gives a correct filling appearance only for planar polygons. For all
+        other polygons, you'll find orientations in which the edges of the
+        polygon intersect in the projection. This will lead to an incorrect
+        visualization of the 3D area.
+
+        If you need filled areas, it is recommended to create them via
+        `~mpl_toolkits.mplot3d.axes3d.Axes3D.plot_trisurf`, which creates a
+        triangulation and thus generates consistent surfaces.
+    """
+
+    def __init__(self, verts, *args, zsort='average', shade=False,
+                 lightsource=None, **kwargs):
+        """
+        Parameters
+        ----------
+        verts : list of (N, 3) array-like
+            The sequence of polygons [*verts0*, *verts1*, ...] where each
+            element *verts_i* defines the vertices of polygon *i* as a 2D
+            array-like of shape (N, 3).
+        zsort : {'average', 'min', 'max'}, default: 'average'
+            The calculation method for the z-order.
+            See `~.Poly3DCollection.set_zsort` for details.
+        shade : bool, default: False
+            Whether to shade *facecolors* and *edgecolors*. When activating
+            *shade*, *facecolors* and/or *edgecolors* must be provided.
+
+            .. versionadded:: 3.7
+
+        lightsource : `~matplotlib.colors.LightSource`, optional
+            The lightsource to use when *shade* is True.
+
+            .. versionadded:: 3.7
+
+        *args, **kwargs
+            All other parameters are forwarded to `.PolyCollection`.
+
+        Notes
+        -----
+        Note that this class does a bit of magic with the _facecolors
+        and _edgecolors properties.
+        """
+        if shade:
+            normals = _generate_normals(verts)
+            facecolors = kwargs.get('facecolors', None)
+            if facecolors is not None:
+                kwargs['facecolors'] = _shade_colors(
+                    facecolors, normals, lightsource
+                )
+
+            edgecolors = kwargs.get('edgecolors', None)
+            if edgecolors is not None:
+                kwargs['edgecolors'] = _shade_colors(
+                    edgecolors, normals, lightsource
+                )
+            if facecolors is None and edgecolors is None:
+                raise ValueError(
+                    "You must provide facecolors, edgecolors, or both for "
+                    "shade to work.")
+        super().__init__(verts, *args, **kwargs)
+        if isinstance(verts, np.ndarray):
+            if verts.ndim != 3:
+                raise ValueError('verts must be a list of (N, 3) array-like')
+        else:
+            if any(len(np.shape(vert)) != 2 for vert in verts):
+                raise ValueError('verts must be a list of (N, 3) array-like')
+        self.set_zsort(zsort)
+        self._codes3d = None
+
+    _zsort_functions = {
+        'average': np.average,
+        'min': np.min,
+        'max': np.max,
+    }
+
+    def set_zsort(self, zsort):
+        """
+        Set the calculation method for the z-order.
+
+        Parameters
+        ----------
+        zsort : {'average', 'min', 'max'}
+            The function applied on the z-coordinates of the vertices in the
+            viewer's coordinate system, to determine the z-order.
+        """
+        self._zsortfunc = self._zsort_functions[zsort]
+        self._sort_zpos = None
+        self.stale = True
+
+    def get_vector(self, segments3d):
+        """Optimize points for projection."""
+        if len(segments3d):
+            xs, ys, zs = np.vstack(segments3d).T
+        else:  # vstack can't stack zero arrays.
+            xs, ys, zs = [], [], []
+        ones = np.ones(len(xs))
+        self._vec = np.array([xs, ys, zs, ones])
+
+        indices = [0, *np.cumsum([len(segment) for segment in segments3d])]
+        self._segslices = [*map(slice, indices[:-1], indices[1:])]
+
+    def set_verts(self, verts, closed=True):
+        """
+        Set 3D vertices.
+
+        Parameters
+        ----------
+        verts : list of (N, 3) array-like
+            The sequence of polygons [*verts0*, *verts1*, ...] where each
+            element *verts_i* defines the vertices of polygon *i* as a 2D
+            array-like of shape (N, 3).
+        closed : bool, default: True
+            Whether the polygon should be closed by adding a CLOSEPOLY
+            connection at the end.
+        """
+        self.get_vector(verts)
+        # 2D verts will be updated at draw time
+        super().set_verts([], False)
+        self._closed = closed
+
+    def set_verts_and_codes(self, verts, codes):
+        """Set 3D vertices with path codes."""
+        # set vertices with closed=False to prevent PolyCollection from
+        # setting path codes
+        self.set_verts(verts, closed=False)
+        # and set our own codes instead.
+        self._codes3d = codes
+
+    def set_3d_properties(self):
+        # Force the collection to initialize the face and edgecolors
+        # just in case it is a scalarmappable with a colormap.
+        self.update_scalarmappable()
+        self._sort_zpos = None
+        self.set_zsort('average')
+        self._facecolor3d = PolyCollection.get_facecolor(self)
+        self._edgecolor3d = PolyCollection.get_edgecolor(self)
+        self._alpha3d = PolyCollection.get_alpha(self)
+        self.stale = True
+
+    def set_sort_zpos(self, val):
+        """Set the position to use for z-sorting."""
+        self._sort_zpos = val
+        self.stale = True
+
+    def do_3d_projection(self):
+        """
+        Perform the 3D projection for this object.
+        """
+        if self._A is not None:
+            # force update of color mapping because we re-order them
+            # below.  If we do not do this here, the 2D draw will call
+            # this, but we will never port the color mapped values back
+            # to the 3D versions.
+            #
+            # We hold the 3D versions in a fixed order (the order the user
+            # passed in) and sort the 2D version by view depth.
+            self.update_scalarmappable()
+            if self._face_is_mapped:
+                self._facecolor3d = self._facecolors
+            if self._edge_is_mapped:
+                self._edgecolor3d = self._edgecolors
+        txs, tys, tzs = proj3d._proj_transform_vec(self._vec, self.axes.M)
+        xyzlist = [(txs[sl], tys[sl], tzs[sl]) for sl in self._segslices]
+
+        # This extra fuss is to re-order face / edge colors
+        cface = self._facecolor3d
+        cedge = self._edgecolor3d
+        if len(cface) != len(xyzlist):
+            cface = cface.repeat(len(xyzlist), axis=0)
+        if len(cedge) != len(xyzlist):
+            if len(cedge) == 0:
+                cedge = cface
+            else:
+                cedge = cedge.repeat(len(xyzlist), axis=0)
+
+        if xyzlist:
+            # sort by depth (furthest drawn first)
+            z_segments_2d = sorted(
+                ((self._zsortfunc(zs), np.column_stack([xs, ys]), fc, ec, idx)
+                 for idx, ((xs, ys, zs), fc, ec)
+                 in enumerate(zip(xyzlist, cface, cedge))),
+                key=lambda x: x[0], reverse=True)
+
+            _, segments_2d, self._facecolors2d, self._edgecolors2d, idxs = \
+                zip(*z_segments_2d)
+        else:
+            segments_2d = []
+            self._facecolors2d = np.empty((0, 4))
+            self._edgecolors2d = np.empty((0, 4))
+            idxs = []
+
+        if self._codes3d is not None:
+            codes = [self._codes3d[idx] for idx in idxs]
+            PolyCollection.set_verts_and_codes(self, segments_2d, codes)
+        else:
+            PolyCollection.set_verts(self, segments_2d, self._closed)
+
+        if len(self._edgecolor3d) != len(cface):
+            self._edgecolors2d = self._edgecolor3d
+
+        # Return zorder value
+        if self._sort_zpos is not None:
+            zvec = np.array([[0], [0], [self._sort_zpos], [1]])
+            ztrans = proj3d._proj_transform_vec(zvec, self.axes.M)
+            return ztrans[2][0]
+        elif tzs.size > 0:
+            # FIXME: Some results still don't look quite right.
+            #        In particular, examine contourf3d_demo2.py
+            #        with az = -54 and elev = -45.
+            return np.min(tzs)
+        else:
+            return np.nan
+
+    def set_facecolor(self, colors):
+        # docstring inherited
+        super().set_facecolor(colors)
+        self._facecolor3d = PolyCollection.get_facecolor(self)
+
+    def set_edgecolor(self, colors):
+        # docstring inherited
+        super().set_edgecolor(colors)
+        self._edgecolor3d = PolyCollection.get_edgecolor(self)
+
+    def set_alpha(self, alpha):
+        # docstring inherited
+        artist.Artist.set_alpha(self, alpha)
+        try:
+            self._facecolor3d = mcolors.to_rgba_array(
+                self._facecolor3d, self._alpha)
+        except (AttributeError, TypeError, IndexError):
+            pass
+        try:
+            self._edgecolors = mcolors.to_rgba_array(
+                    self._edgecolor3d, self._alpha)
+        except (AttributeError, TypeError, IndexError):
+            pass
+        self.stale = True
+
+    def get_facecolor(self):
+        # docstring inherited
+        # self._facecolors2d is not initialized until do_3d_projection
+        if not hasattr(self, '_facecolors2d'):
+            self.axes.M = self.axes.get_proj()
+            self.do_3d_projection()
+        return np.asarray(self._facecolors2d)
+
+    def get_edgecolor(self):
+        # docstring inherited
+        # self._edgecolors2d is not initialized until do_3d_projection
+        if not hasattr(self, '_edgecolors2d'):
+            self.axes.M = self.axes.get_proj()
+            self.do_3d_projection()
+        return np.asarray(self._edgecolors2d)
+
+
+def poly_collection_2d_to_3d(col, zs=0, zdir='z'):
+    """
+    Convert a `.PolyCollection` into a `.Poly3DCollection` object.
+
+    Parameters
+    ----------
+    col : `~matplotlib.collections.PolyCollection`
+        The collection to convert.
+    zs : float or array of floats
+        The location or locations to place the polygons in the collection along
+        the *zdir* axis. Default: 0.
+    zdir : {'x', 'y', 'z'}
+        The axis in which to place the patches. Default: 'z'.
+        See `.get_dir_vector` for a description of the values.
+    """
+    segments_3d, codes = _paths_to_3d_segments_with_codes(
+            col.get_paths(), zs, zdir)
+    col.__class__ = Poly3DCollection
+    col.set_verts_and_codes(segments_3d, codes)
+    col.set_3d_properties()
+
+
+def juggle_axes(xs, ys, zs, zdir):
+    """
+    Reorder coordinates so that 2D *xs*, *ys* can be plotted in the plane
+    orthogonal to *zdir*. *zdir* is normally 'x', 'y' or 'z'. However, if
+    *zdir* starts with a '-' it is interpreted as a compensation for
+    `rotate_axes`.
+    """
+    if zdir == 'x':
+        return zs, xs, ys
+    elif zdir == 'y':
+        return xs, zs, ys
+    elif zdir[0] == '-':
+        return rotate_axes(xs, ys, zs, zdir)
+    else:
+        return xs, ys, zs
+
+
+def rotate_axes(xs, ys, zs, zdir):
+    """
+    Reorder coordinates so that the axes are rotated with *zdir* along
+    the original z axis. Prepending the axis with a '-' does the
+    inverse transform, so *zdir* can be 'x', '-x', 'y', '-y', 'z' or '-z'.
+    """
+    if zdir in ('x', '-y'):
+        return ys, zs, xs
+    elif zdir in ('-x', 'y'):
+        return zs, xs, ys
+    else:
+        return xs, ys, zs
+
+
+def _zalpha(colors, zs):
+    """Modify the alphas of the color list according to depth."""
+    # FIXME: This only works well if the points for *zs* are well-spaced
+    #        in all three dimensions. Otherwise, at certain orientations,
+    #        the min and max zs are very close together.
+    #        Should really normalize against the viewing depth.
+    if len(colors) == 0 or len(zs) == 0:
+        return np.zeros((0, 4))
+    norm = Normalize(min(zs), max(zs))
+    sats = 1 - norm(zs) * 0.7
+    rgba = np.broadcast_to(mcolors.to_rgba_array(colors), (len(zs), 4))
+    return np.column_stack([rgba[:, :3], rgba[:, 3] * sats])
+
+
+def _generate_normals(polygons):
+    """
+    Compute the normals of a list of polygons, one normal per polygon.
+
+    Normals point towards the viewer for a face with its vertices in
+    counterclockwise order, following the right hand rule.
+
+    Uses three points equally spaced around the polygon. This method assumes
+    that the points are in a plane. Otherwise, more than one shade is required,
+    which is not supported.
+
+    Parameters
+    ----------
+    polygons : list of (M_i, 3) array-like, or (..., M, 3) array-like
+        A sequence of polygons to compute normals for, which can have
+        varying numbers of vertices. If the polygons all have the same
+        number of vertices and array is passed, then the operation will
+        be vectorized.
+
+    Returns
+    -------
+    normals : (..., 3) array
+        A normal vector estimated for the polygon.
+    """
+    if isinstance(polygons, np.ndarray):
+        # optimization: polygons all have the same number of points, so can
+        # vectorize
+        n = polygons.shape[-2]
+        i1, i2, i3 = 0, n//3, 2*n//3
+        v1 = polygons[..., i1, :] - polygons[..., i2, :]
+        v2 = polygons[..., i2, :] - polygons[..., i3, :]
+    else:
+        # The subtraction doesn't vectorize because polygons is jagged.
+        v1 = np.empty((len(polygons), 3))
+        v2 = np.empty((len(polygons), 3))
+        for poly_i, ps in enumerate(polygons):
+            n = len(ps)
+            i1, i2, i3 = 0, n//3, 2*n//3
+            v1[poly_i, :] = ps[i1, :] - ps[i2, :]
+            v2[poly_i, :] = ps[i2, :] - ps[i3, :]
+    return np.cross(v1, v2)
+
+
+def _shade_colors(color, normals, lightsource=None):
+    """
+    Shade *color* using normal vectors given by *normals*,
+    assuming a *lightsource* (using default position if not given).
+    *color* can also be an array of the same length as *normals*.
+    """
+    if lightsource is None:
+        # chosen for backwards-compatibility
+        lightsource = mcolors.LightSource(azdeg=225, altdeg=19.4712)
+
+    with np.errstate(invalid="ignore"):
+        shade = ((normals / np.linalg.norm(normals, axis=1, keepdims=True))
+                 @ lightsource.direction)
+    mask = ~np.isnan(shade)
+
+    if mask.any():
+        # convert dot product to allowed shading fractions
+        in_norm = mcolors.Normalize(-1, 1)
+        out_norm = mcolors.Normalize(0.3, 1).inverse
+
+        def norm(x):
+            return out_norm(in_norm(x))
+
+        shade[~mask] = 0
+
+        color = mcolors.to_rgba_array(color)
+        # shape of color should be (M, 4) (where M is number of faces)
+        # shape of shade should be (M,)
+        # colors should have final shape of (M, 4)
+        alpha = color[:, 3]
+        colors = norm(shade)[:, np.newaxis] * color
+        colors[:, 3] = alpha
+    else:
+        colors = np.asanyarray(color).copy()
+
+    return colors
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axes3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axes3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..71cd8f062d407303c5100397a6e382ddd6a25aeb
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axes3d.py
@@ -0,0 +1,3750 @@
+"""
+axes3d.py, original mplot3d version by John Porter
+Created: 23 Sep 2005
+
+Parts fixed by Reinier Heeres <reinier@heeres.eu>
+Minor additions by Ben Axelrod <baxelrod@coroware.com>
+Significant updates and revisions by Ben Root <ben.v.root@gmail.com>
+
+Module containing Axes3D, an object which can plot 3D objects on a
+2D matplotlib figure.
+"""
+
+from collections import defaultdict
+import itertools
+import math
+import textwrap
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import _api, cbook, _docstring, _preprocess_data
+import matplotlib.artist as martist
+import matplotlib.collections as mcoll
+import matplotlib.colors as mcolors
+import matplotlib.image as mimage
+import matplotlib.lines as mlines
+import matplotlib.patches as mpatches
+import matplotlib.container as mcontainer
+import matplotlib.transforms as mtransforms
+from matplotlib.axes import Axes
+from matplotlib.axes._base import _axis_method_wrapper, _process_plot_format
+from matplotlib.transforms import Bbox
+from matplotlib.tri._triangulation import Triangulation
+
+from . import art3d
+from . import proj3d
+from . import axis3d
+
+
+@_docstring.interpd
+@_api.define_aliases({
+    "xlim": ["xlim3d"], "ylim": ["ylim3d"], "zlim": ["zlim3d"]})
+class Axes3D(Axes):
+    """
+    3D Axes object.
+
+    .. note::
+
+        As a user, you do not instantiate Axes directly, but use Axes creation
+        methods instead; e.g. from `.pyplot` or `.Figure`:
+        `~.pyplot.subplots`, `~.pyplot.subplot_mosaic` or `.Figure.add_axes`.
+    """
+    name = '3d'
+
+    _axis_names = ("x", "y", "z")
+    Axes._shared_axes["z"] = cbook.Grouper()
+    Axes._shared_axes["view"] = cbook.Grouper()
+
+    def __init__(
+            self, fig, rect=None, *args,
+            elev=30, azim=-60, roll=0, sharez=None, proj_type='persp',
+            box_aspect=None, computed_zorder=True, focal_length=None,
+            shareview=None,
+            **kwargs):
+        """
+        Parameters
+        ----------
+        fig : Figure
+            The parent figure.
+        rect : tuple (left, bottom, width, height), default: None.
+            The ``(left, bottom, width, height)`` Axes position.
+        elev : float, default: 30
+            The elevation angle in degrees rotates the camera above and below
+            the x-y plane, with a positive angle corresponding to a location
+            above the plane.
+        azim : float, default: -60
+            The azimuthal angle in degrees rotates the camera about the z axis,
+            with a positive angle corresponding to a right-handed rotation. In
+            other words, a positive azimuth rotates the camera about the origin
+            from its location along the +x axis towards the +y axis.
+        roll : float, default: 0
+            The roll angle in degrees rotates the camera about the viewing
+            axis. A positive angle spins the camera clockwise, causing the
+            scene to rotate counter-clockwise.
+        sharez : Axes3D, optional
+            Other Axes to share z-limits with.  Note that it is not possible to
+            unshare axes.
+        proj_type : {'persp', 'ortho'}
+            The projection type, default 'persp'.
+        box_aspect : 3-tuple of floats, default: None
+            Changes the physical dimensions of the Axes3D, such that the ratio
+            of the axis lengths in display units is x:y:z.
+            If None, defaults to 4:4:3
+        computed_zorder : bool, default: True
+            If True, the draw order is computed based on the average position
+            of the `.Artist`\\s along the view direction.
+            Set to False if you want to manually control the order in which
+            Artists are drawn on top of each other using their *zorder*
+            attribute. This can be used for fine-tuning if the automatic order
+            does not produce the desired result. Note however, that a manual
+            zorder will only be correct for a limited view angle. If the figure
+            is rotated by the user, it will look wrong from certain angles.
+        focal_length : float, default: None
+            For a projection type of 'persp', the focal length of the virtual
+            camera. Must be > 0. If None, defaults to 1.
+            For a projection type of 'ortho', must be set to either None
+            or infinity (numpy.inf). If None, defaults to infinity.
+            The focal length can be computed from a desired Field Of View via
+            the equation: focal_length = 1/tan(FOV/2)
+        shareview : Axes3D, optional
+            Other Axes to share view angles with.  Note that it is not possible
+            to unshare axes.
+
+        **kwargs
+            Other optional keyword arguments:
+
+            %(Axes3D:kwdoc)s
+        """
+
+        if rect is None:
+            rect = [0.0, 0.0, 1.0, 1.0]
+
+        self.initial_azim = azim
+        self.initial_elev = elev
+        self.initial_roll = roll
+        self.set_proj_type(proj_type, focal_length)
+        self.computed_zorder = computed_zorder
+
+        self.xy_viewLim = Bbox.unit()
+        self.zz_viewLim = Bbox.unit()
+        xymargin = 0.05 * 10/11  # match mpl3.8 appearance
+        self.xy_dataLim = Bbox([[xymargin, xymargin],
+                                [1 - xymargin, 1 - xymargin]])
+        # z-limits are encoded in the x-component of the Bbox, y is un-used
+        self.zz_dataLim = Bbox.unit()
+
+        # inhibit autoscale_view until the axes are defined
+        # they can't be defined until Axes.__init__ has been called
+        self.view_init(self.initial_elev, self.initial_azim, self.initial_roll)
+
+        self._sharez = sharez
+        if sharez is not None:
+            self._shared_axes["z"].join(self, sharez)
+            self._adjustable = 'datalim'
+
+        self._shareview = shareview
+        if shareview is not None:
+            self._shared_axes["view"].join(self, shareview)
+
+        if kwargs.pop('auto_add_to_figure', False):
+            raise AttributeError(
+                'auto_add_to_figure is no longer supported for Axes3D. '
+                'Use fig.add_axes(ax) instead.'
+            )
+
+        super().__init__(
+            fig, rect, frameon=True, box_aspect=box_aspect, *args, **kwargs
+        )
+        # Disable drawing of axes by base class
+        super().set_axis_off()
+        # Enable drawing of axes by Axes3D class
+        self.set_axis_on()
+        self.M = None
+        self.invM = None
+
+        self._view_margin = 1/48  # default value to match mpl3.8
+        self.autoscale_view()
+
+        # func used to format z -- fall back on major formatters
+        self.fmt_zdata = None
+
+        self.mouse_init()
+        self.figure.canvas.callbacks._connect_picklable(
+            'motion_notify_event', self._on_move)
+        self.figure.canvas.callbacks._connect_picklable(
+            'button_press_event', self._button_press)
+        self.figure.canvas.callbacks._connect_picklable(
+            'button_release_event', self._button_release)
+        self.set_top_view()
+
+        self.patch.set_linewidth(0)
+        # Calculate the pseudo-data width and height
+        pseudo_bbox = self.transLimits.inverted().transform([(0, 0), (1, 1)])
+        self._pseudo_w, self._pseudo_h = pseudo_bbox[1] - pseudo_bbox[0]
+
+        # mplot3d currently manages its own spines and needs these turned off
+        # for bounding box calculations
+        self.spines[:].set_visible(False)
+
+    def set_axis_off(self):
+        self._axis3don = False
+        self.stale = True
+
+    def set_axis_on(self):
+        self._axis3don = True
+        self.stale = True
+
+    def convert_zunits(self, z):
+        """
+        For artists in an Axes, if the zaxis has units support,
+        convert *z* using zaxis unit type
+        """
+        return self.zaxis.convert_units(z)
+
+    def set_top_view(self):
+        # this happens to be the right view for the viewing coordinates
+        # moved up and to the left slightly to fit labels and axes
+        xdwl = 0.95 / self._dist
+        xdw = 0.9 / self._dist
+        ydwl = 0.95 / self._dist
+        ydw = 0.9 / self._dist
+        # Set the viewing pane.
+        self.viewLim.intervalx = (-xdwl, xdw)
+        self.viewLim.intervaly = (-ydwl, ydw)
+        self.stale = True
+
+    def _init_axis(self):
+        """Init 3D Axes; overrides creation of regular X/Y Axes."""
+        self.xaxis = axis3d.XAxis(self)
+        self.yaxis = axis3d.YAxis(self)
+        self.zaxis = axis3d.ZAxis(self)
+
+    def get_zaxis(self):
+        """Return the ``ZAxis`` (`~.axis3d.Axis`) instance."""
+        return self.zaxis
+
+    get_zgridlines = _axis_method_wrapper("zaxis", "get_gridlines")
+    get_zticklines = _axis_method_wrapper("zaxis", "get_ticklines")
+
+    def _transformed_cube(self, vals):
+        """Return cube with limits from *vals* transformed by self.M."""
+        minx, maxx, miny, maxy, minz, maxz = vals
+        xyzs = [(minx, miny, minz),
+                (maxx, miny, minz),
+                (maxx, maxy, minz),
+                (minx, maxy, minz),
+                (minx, miny, maxz),
+                (maxx, miny, maxz),
+                (maxx, maxy, maxz),
+                (minx, maxy, maxz)]
+        return proj3d._proj_points(xyzs, self.M)
+
+    def set_aspect(self, aspect, adjustable=None, anchor=None, share=False):
+        """
+        Set the aspect ratios.
+
+        Parameters
+        ----------
+        aspect : {'auto', 'equal', 'equalxy', 'equalxz', 'equalyz'}
+            Possible values:
+
+            =========   ==================================================
+            value       description
+            =========   ==================================================
+            'auto'      automatic; fill the position rectangle with data.
+            'equal'     adapt all the axes to have equal aspect ratios.
+            'equalxy'   adapt the x and y axes to have equal aspect ratios.
+            'equalxz'   adapt the x and z axes to have equal aspect ratios.
+            'equalyz'   adapt the y and z axes to have equal aspect ratios.
+            =========   ==================================================
+
+        adjustable : None or {'box', 'datalim'}, optional
+            If not *None*, this defines which parameter will be adjusted to
+            meet the required aspect. See `.set_adjustable` for further
+            details.
+
+        anchor : None or str or 2-tuple of float, optional
+            If not *None*, this defines where the Axes will be drawn if there
+            is extra space due to aspect constraints. The most common way to
+            specify the anchor are abbreviations of cardinal directions:
+
+            =====   =====================
+            value   description
+            =====   =====================
+            'C'     centered
+            'SW'    lower left corner
+            'S'     middle of bottom edge
+            'SE'    lower right corner
+            etc.
+            =====   =====================
+
+            See `~.Axes.set_anchor` for further details.
+
+        share : bool, default: False
+            If ``True``, apply the settings to all shared Axes.
+
+        See Also
+        --------
+        mpl_toolkits.mplot3d.axes3d.Axes3D.set_box_aspect
+        """
+        _api.check_in_list(('auto', 'equal', 'equalxy', 'equalyz', 'equalxz'),
+                           aspect=aspect)
+        super().set_aspect(
+            aspect='auto', adjustable=adjustable, anchor=anchor, share=share)
+        self._aspect = aspect
+
+        if aspect in ('equal', 'equalxy', 'equalxz', 'equalyz'):
+            ax_indices = self._equal_aspect_axis_indices(aspect)
+
+            view_intervals = np.array([self.xaxis.get_view_interval(),
+                                       self.yaxis.get_view_interval(),
+                                       self.zaxis.get_view_interval()])
+            ptp = np.ptp(view_intervals, axis=1)
+            if self._adjustable == 'datalim':
+                mean = np.mean(view_intervals, axis=1)
+                scale = max(ptp[ax_indices] / self._box_aspect[ax_indices])
+                deltas = scale * self._box_aspect
+
+                for i, set_lim in enumerate((self.set_xlim3d,
+                                             self.set_ylim3d,
+                                             self.set_zlim3d)):
+                    if i in ax_indices:
+                        set_lim(mean[i] - deltas[i]/2., mean[i] + deltas[i]/2.,
+                                auto=True, view_margin=None)
+            else:  # 'box'
+                # Change the box aspect such that the ratio of the length of
+                # the unmodified axis to the length of the diagonal
+                # perpendicular to it remains unchanged.
+                box_aspect = np.array(self._box_aspect)
+                box_aspect[ax_indices] = ptp[ax_indices]
+                remaining_ax_indices = {0, 1, 2}.difference(ax_indices)
+                if remaining_ax_indices:
+                    remaining = remaining_ax_indices.pop()
+                    old_diag = np.linalg.norm(self._box_aspect[ax_indices])
+                    new_diag = np.linalg.norm(box_aspect[ax_indices])
+                    box_aspect[remaining] *= new_diag / old_diag
+                self.set_box_aspect(box_aspect)
+
+    def _equal_aspect_axis_indices(self, aspect):
+        """
+        Get the indices for which of the x, y, z axes are constrained to have
+        equal aspect ratios.
+
+        Parameters
+        ----------
+        aspect : {'auto', 'equal', 'equalxy', 'equalxz', 'equalyz'}
+            See descriptions in docstring for `.set_aspect()`.
+        """
+        ax_indices = []  # aspect == 'auto'
+        if aspect == 'equal':
+            ax_indices = [0, 1, 2]
+        elif aspect == 'equalxy':
+            ax_indices = [0, 1]
+        elif aspect == 'equalxz':
+            ax_indices = [0, 2]
+        elif aspect == 'equalyz':
+            ax_indices = [1, 2]
+        return ax_indices
+
+    def set_box_aspect(self, aspect, *, zoom=1):
+        """
+        Set the Axes box aspect.
+
+        The box aspect is the ratio of height to width in display
+        units for each face of the box when viewed perpendicular to
+        that face.  This is not to be confused with the data aspect (see
+        `~.Axes3D.set_aspect`). The default ratios are 4:4:3 (x:y:z).
+
+        To simulate having equal aspect in data space, set the box
+        aspect to match your data range in each dimension.
+
+        *zoom* controls the overall size of the Axes3D in the figure.
+
+        Parameters
+        ----------
+        aspect : 3-tuple of floats or None
+            Changes the physical dimensions of the Axes3D, such that the ratio
+            of the axis lengths in display units is x:y:z.
+            If None, defaults to (4, 4, 3).
+
+        zoom : float, default: 1
+            Control overall size of the Axes3D in the figure. Must be > 0.
+        """
+        if zoom <= 0:
+            raise ValueError(f'Argument zoom = {zoom} must be > 0')
+
+        if aspect is None:
+            aspect = np.asarray((4, 4, 3), dtype=float)
+        else:
+            aspect = np.asarray(aspect, dtype=float)
+            _api.check_shape((3,), aspect=aspect)
+        # The scale 1.8294640721620434 is tuned to match the mpl3.2 appearance.
+        # The 25/24 factor is to compensate for the change in automargin
+        # behavior in mpl3.9. This comes from the padding of 1/48 on both sides
+        # of the axes in mpl3.8.
+        aspect *= 1.8294640721620434 * 25/24 * zoom / np.linalg.norm(aspect)
+
+        self._box_aspect = self._roll_to_vertical(aspect, reverse=True)
+        self.stale = True
+
+    def apply_aspect(self, position=None):
+        if position is None:
+            position = self.get_position(original=True)
+
+        # in the superclass, we would go through and actually deal with axis
+        # scales and box/datalim. Those are all irrelevant - all we need to do
+        # is make sure our coordinate system is square.
+        trans = self.get_figure().transSubfigure
+        bb = mtransforms.Bbox.unit().transformed(trans)
+        # this is the physical aspect of the panel (or figure):
+        fig_aspect = bb.height / bb.width
+
+        box_aspect = 1
+        pb = position.frozen()
+        pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)
+        self._set_position(pb1.anchored(self.get_anchor(), pb), 'active')
+
+    @martist.allow_rasterization
+    def draw(self, renderer):
+        if not self.get_visible():
+            return
+        self._unstale_viewLim()
+
+        # draw the background patch
+        self.patch.draw(renderer)
+        self._frameon = False
+
+        # first, set the aspect
+        # this is duplicated from `axes._base._AxesBase.draw`
+        # but must be called before any of the artist are drawn as
+        # it adjusts the view limits and the size of the bounding box
+        # of the Axes
+        locator = self.get_axes_locator()
+        self.apply_aspect(locator(self, renderer) if locator else None)
+
+        # add the projection matrix to the renderer
+        self.M = self.get_proj()
+        self.invM = np.linalg.inv(self.M)
+
+        collections_and_patches = (
+            artist for artist in self._children
+            if isinstance(artist, (mcoll.Collection, mpatches.Patch))
+            and artist.get_visible())
+        if self.computed_zorder:
+            # Calculate projection of collections and patches and zorder
+            # them. Make sure they are drawn above the grids.
+            zorder_offset = max(axis.get_zorder()
+                                for axis in self._axis_map.values()) + 1
+            collection_zorder = patch_zorder = zorder_offset
+
+            for artist in sorted(collections_and_patches,
+                                 key=lambda artist: artist.do_3d_projection(),
+                                 reverse=True):
+                if isinstance(artist, mcoll.Collection):
+                    artist.zorder = collection_zorder
+                    collection_zorder += 1
+                elif isinstance(artist, mpatches.Patch):
+                    artist.zorder = patch_zorder
+                    patch_zorder += 1
+        else:
+            for artist in collections_and_patches:
+                artist.do_3d_projection()
+
+        if self._axis3don:
+            # Draw panes first
+            for axis in self._axis_map.values():
+                axis.draw_pane(renderer)
+            # Then gridlines
+            for axis in self._axis_map.values():
+                axis.draw_grid(renderer)
+            # Then axes, labels, text, and ticks
+            for axis in self._axis_map.values():
+                axis.draw(renderer)
+
+        # Then rest
+        super().draw(renderer)
+
+    def get_axis_position(self):
+        tc = self._transformed_cube(self.get_w_lims())
+        xhigh = tc[1][2] > tc[2][2]
+        yhigh = tc[3][2] > tc[2][2]
+        zhigh = tc[0][2] > tc[2][2]
+        return xhigh, yhigh, zhigh
+
+    def update_datalim(self, xys, **kwargs):
+        """
+        Not implemented in `~mpl_toolkits.mplot3d.axes3d.Axes3D`.
+        """
+        pass
+
+    get_autoscalez_on = _axis_method_wrapper("zaxis", "_get_autoscale_on")
+    set_autoscalez_on = _axis_method_wrapper("zaxis", "_set_autoscale_on")
+
+    def get_zmargin(self):
+        """
+        Retrieve autoscaling margin of the z-axis.
+
+        .. versionadded:: 3.9
+
+        Returns
+        -------
+        zmargin : float
+
+        See Also
+        --------
+        mpl_toolkits.mplot3d.axes3d.Axes3D.set_zmargin
+        """
+        return self._zmargin
+
+    def set_zmargin(self, m):
+        """
+        Set padding of Z data limits prior to autoscaling.
+
+        *m* times the data interval will be added to each end of that interval
+        before it is used in autoscaling.  If *m* is negative, this will clip
+        the data range instead of expanding it.
+
+        For example, if your data is in the range [0, 2], a margin of 0.1 will
+        result in a range [-0.2, 2.2]; a margin of -0.1 will result in a range
+        of [0.2, 1.8].
+
+        Parameters
+        ----------
+        m : float greater than -0.5
+        """
+        if m <= -0.5:
+            raise ValueError("margin must be greater than -0.5")
+        self._zmargin = m
+        self._request_autoscale_view("z")
+        self.stale = True
+
+    def margins(self, *margins, x=None, y=None, z=None, tight=True):
+        """
+        Set or retrieve autoscaling margins.
+
+        See `.Axes.margins` for full documentation.  Because this function
+        applies to 3D Axes, it also takes a *z* argument, and returns
+        ``(xmargin, ymargin, zmargin)``.
+        """
+        if margins and (x is not None or y is not None or z is not None):
+            raise TypeError('Cannot pass both positional and keyword '
+                            'arguments for x, y, and/or z.')
+        elif len(margins) == 1:
+            x = y = z = margins[0]
+        elif len(margins) == 3:
+            x, y, z = margins
+        elif margins:
+            raise TypeError('Must pass a single positional argument for all '
+                            'margins, or one for each margin (x, y, z).')
+
+        if x is None and y is None and z is None:
+            if tight is not True:
+                _api.warn_external(f'ignoring tight={tight!r} in get mode')
+            return self._xmargin, self._ymargin, self._zmargin
+
+        if x is not None:
+            self.set_xmargin(x)
+        if y is not None:
+            self.set_ymargin(y)
+        if z is not None:
+            self.set_zmargin(z)
+
+        self.autoscale_view(
+            tight=tight, scalex=(x is not None), scaley=(y is not None),
+            scalez=(z is not None)
+        )
+
+    def autoscale(self, enable=True, axis='both', tight=None):
+        """
+        Convenience method for simple axis view autoscaling.
+
+        See `.Axes.autoscale` for full documentation.  Because this function
+        applies to 3D Axes, *axis* can also be set to 'z', and setting *axis*
+        to 'both' autoscales all three axes.
+        """
+        if enable is None:
+            scalex = True
+            scaley = True
+            scalez = True
+        else:
+            if axis in ['x', 'both']:
+                self.set_autoscalex_on(enable)
+                scalex = self.get_autoscalex_on()
+            else:
+                scalex = False
+            if axis in ['y', 'both']:
+                self.set_autoscaley_on(enable)
+                scaley = self.get_autoscaley_on()
+            else:
+                scaley = False
+            if axis in ['z', 'both']:
+                self.set_autoscalez_on(enable)
+                scalez = self.get_autoscalez_on()
+            else:
+                scalez = False
+        if scalex:
+            self._request_autoscale_view("x", tight=tight)
+        if scaley:
+            self._request_autoscale_view("y", tight=tight)
+        if scalez:
+            self._request_autoscale_view("z", tight=tight)
+
+    def auto_scale_xyz(self, X, Y, Z=None, had_data=None):
+        # This updates the bounding boxes as to keep a record as to what the
+        # minimum sized rectangular volume holds the data.
+        if np.shape(X) == np.shape(Y):
+            self.xy_dataLim.update_from_data_xy(
+                np.column_stack([np.ravel(X), np.ravel(Y)]), not had_data)
+        else:
+            self.xy_dataLim.update_from_data_x(X, not had_data)
+            self.xy_dataLim.update_from_data_y(Y, not had_data)
+        if Z is not None:
+            self.zz_dataLim.update_from_data_x(Z, not had_data)
+        # Let autoscale_view figure out how to use this data.
+        self.autoscale_view()
+
+    def autoscale_view(self, tight=None,
+                       scalex=True, scaley=True, scalez=True):
+        """
+        Autoscale the view limits using the data limits.
+
+        See `.Axes.autoscale_view` for full documentation.  Because this
+        function applies to 3D Axes, it also takes a *scalez* argument.
+        """
+        # This method looks at the rectangular volume (see above)
+        # of data and decides how to scale the view portal to fit it.
+        if tight is None:
+            _tight = self._tight
+            if not _tight:
+                # if image data only just use the datalim
+                for artist in self._children:
+                    if isinstance(artist, mimage.AxesImage):
+                        _tight = True
+                    elif isinstance(artist, (mlines.Line2D, mpatches.Patch)):
+                        _tight = False
+                        break
+        else:
+            _tight = self._tight = bool(tight)
+
+        if scalex and self.get_autoscalex_on():
+            x0, x1 = self.xy_dataLim.intervalx
+            xlocator = self.xaxis.get_major_locator()
+            x0, x1 = xlocator.nonsingular(x0, x1)
+            if self._xmargin > 0:
+                delta = (x1 - x0) * self._xmargin
+                x0 -= delta
+                x1 += delta
+            if not _tight:
+                x0, x1 = xlocator.view_limits(x0, x1)
+            self.set_xbound(x0, x1, self._view_margin)
+
+        if scaley and self.get_autoscaley_on():
+            y0, y1 = self.xy_dataLim.intervaly
+            ylocator = self.yaxis.get_major_locator()
+            y0, y1 = ylocator.nonsingular(y0, y1)
+            if self._ymargin > 0:
+                delta = (y1 - y0) * self._ymargin
+                y0 -= delta
+                y1 += delta
+            if not _tight:
+                y0, y1 = ylocator.view_limits(y0, y1)
+            self.set_ybound(y0, y1, self._view_margin)
+
+        if scalez and self.get_autoscalez_on():
+            z0, z1 = self.zz_dataLim.intervalx
+            zlocator = self.zaxis.get_major_locator()
+            z0, z1 = zlocator.nonsingular(z0, z1)
+            if self._zmargin > 0:
+                delta = (z1 - z0) * self._zmargin
+                z0 -= delta
+                z1 += delta
+            if not _tight:
+                z0, z1 = zlocator.view_limits(z0, z1)
+            self.set_zbound(z0, z1, self._view_margin)
+
+    def get_w_lims(self):
+        """Get 3D world limits."""
+        minx, maxx = self.get_xlim3d()
+        miny, maxy = self.get_ylim3d()
+        minz, maxz = self.get_zlim3d()
+        return minx, maxx, miny, maxy, minz, maxz
+
+    def _set_bound3d(self, get_bound, set_lim, axis_inverted,
+                     lower=None, upper=None, view_margin=None):
+        """
+        Set 3D axis bounds.
+        """
+        if upper is None and np.iterable(lower):
+            lower, upper = lower
+
+        old_lower, old_upper = get_bound()
+        if lower is None:
+            lower = old_lower
+        if upper is None:
+            upper = old_upper
+
+        set_lim(sorted((lower, upper), reverse=bool(axis_inverted())),
+                auto=None, view_margin=view_margin)
+
+    def set_xbound(self, lower=None, upper=None, view_margin=None):
+        """
+        Set the lower and upper numerical bounds of the x-axis.
+
+        This method will honor axis inversion regardless of parameter order.
+        It will not change the autoscaling setting (`.get_autoscalex_on()`).
+
+        Parameters
+        ----------
+        lower, upper : float or None
+            The lower and upper bounds. If *None*, the respective axis bound
+            is not modified.
+        view_margin : float or None
+            The margin to apply to the bounds. If *None*, the margin is handled
+            by `.set_xlim`.
+
+        See Also
+        --------
+        get_xbound
+        get_xlim, set_xlim
+        invert_xaxis, xaxis_inverted
+        """
+        self._set_bound3d(self.get_xbound, self.set_xlim, self.xaxis_inverted,
+                          lower, upper, view_margin)
+
+    def set_ybound(self, lower=None, upper=None, view_margin=None):
+        """
+        Set the lower and upper numerical bounds of the y-axis.
+
+        This method will honor axis inversion regardless of parameter order.
+        It will not change the autoscaling setting (`.get_autoscaley_on()`).
+
+        Parameters
+        ----------
+        lower, upper : float or None
+            The lower and upper bounds. If *None*, the respective axis bound
+            is not modified.
+        view_margin : float or None
+            The margin to apply to the bounds. If *None*, the margin is handled
+            by `.set_ylim`.
+
+        See Also
+        --------
+        get_ybound
+        get_ylim, set_ylim
+        invert_yaxis, yaxis_inverted
+        """
+        self._set_bound3d(self.get_ybound, self.set_ylim, self.yaxis_inverted,
+                          lower, upper, view_margin)
+
+    def set_zbound(self, lower=None, upper=None, view_margin=None):
+        """
+        Set the lower and upper numerical bounds of the z-axis.
+        This method will honor axis inversion regardless of parameter order.
+        It will not change the autoscaling setting (`.get_autoscaley_on()`).
+
+        Parameters
+        ----------
+        lower, upper : float or None
+            The lower and upper bounds. If *None*, the respective axis bound
+            is not modified.
+        view_margin : float or None
+            The margin to apply to the bounds. If *None*, the margin is handled
+            by `.set_zlim`.
+
+        See Also
+        --------
+        get_zbound
+        get_zlim, set_zlim
+        invert_zaxis, zaxis_inverted
+        """
+        self._set_bound3d(self.get_zbound, self.set_zlim, self.zaxis_inverted,
+                          lower, upper, view_margin)
+
+    def _set_lim3d(self, axis, lower=None, upper=None, *, emit=True,
+                   auto=False, view_margin=None, axmin=None, axmax=None):
+        """
+        Set 3D axis limits.
+        """
+        if upper is None:
+            if np.iterable(lower):
+                lower, upper = lower
+            elif axmax is None:
+                upper = axis.get_view_interval()[1]
+        if lower is None and axmin is None:
+            lower = axis.get_view_interval()[0]
+        if axmin is not None:
+            if lower is not None:
+                raise TypeError("Cannot pass both 'lower' and 'min'")
+            lower = axmin
+        if axmax is not None:
+            if upper is not None:
+                raise TypeError("Cannot pass both 'upper' and 'max'")
+            upper = axmax
+        if np.isinf(lower) or np.isinf(upper):
+            raise ValueError(f"Axis limits {lower}, {upper} cannot be infinite")
+        if view_margin is None:
+            if mpl.rcParams['axes3d.automargin']:
+                view_margin = self._view_margin
+            else:
+                view_margin = 0
+        delta = (upper - lower) * view_margin
+        lower -= delta
+        upper += delta
+        return axis._set_lim(lower, upper, emit=emit, auto=auto)
+
+    def set_xlim(self, left=None, right=None, *, emit=True, auto=False,
+                 view_margin=None, xmin=None, xmax=None):
+        """
+        Set the 3D x-axis view limits.
+
+        Parameters
+        ----------
+        left : float, optional
+            The left xlim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+            The left and right xlims may also be passed as the tuple
+            (*left*, *right*) as the first positional argument (or as
+            the *left* keyword argument).
+
+            .. ACCEPTS: (left: float, right: float)
+
+        right : float, optional
+            The right xlim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+        emit : bool, default: True
+            Whether to notify observers of limit change.
+
+        auto : bool or None, default: False
+            Whether to turn on autoscaling of the x-axis. *True* turns on,
+            *False* turns off, *None* leaves unchanged.
+
+        view_margin : float, optional
+            The additional margin to apply to the limits.
+
+        xmin, xmax : float, optional
+            They are equivalent to left and right respectively, and it is an
+            error to pass both *xmin* and *left* or *xmax* and *right*.
+
+        Returns
+        -------
+        left, right : (float, float)
+            The new x-axis limits in data coordinates.
+
+        See Also
+        --------
+        get_xlim
+        set_xbound, get_xbound
+        invert_xaxis, xaxis_inverted
+
+        Notes
+        -----
+        The *left* value may be greater than the *right* value, in which
+        case the x-axis values will decrease from *left* to *right*.
+
+        Examples
+        --------
+        >>> set_xlim(left, right)
+        >>> set_xlim((left, right))
+        >>> left, right = set_xlim(left, right)
+
+        One limit may be left unchanged.
+
+        >>> set_xlim(right=right_lim)
+
+        Limits may be passed in reverse order to flip the direction of
+        the x-axis. For example, suppose ``x`` represents depth of the
+        ocean in m. The x-axis limits might be set like the following
+        so 5000 m depth is at the left of the plot and the surface,
+        0 m, is at the right.
+
+        >>> set_xlim(5000, 0)
+        """
+        return self._set_lim3d(self.xaxis, left, right, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=xmin, axmax=xmax)
+
+    def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False,
+                 view_margin=None, ymin=None, ymax=None):
+        """
+        Set the 3D y-axis view limits.
+
+        Parameters
+        ----------
+        bottom : float, optional
+            The bottom ylim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+            The bottom and top ylims may also be passed as the tuple
+            (*bottom*, *top*) as the first positional argument (or as
+            the *bottom* keyword argument).
+
+            .. ACCEPTS: (bottom: float, top: float)
+
+        top : float, optional
+            The top ylim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+        emit : bool, default: True
+            Whether to notify observers of limit change.
+
+        auto : bool or None, default: False
+            Whether to turn on autoscaling of the y-axis. *True* turns on,
+            *False* turns off, *None* leaves unchanged.
+
+        view_margin : float, optional
+            The additional margin to apply to the limits.
+
+        ymin, ymax : float, optional
+            They are equivalent to bottom and top respectively, and it is an
+            error to pass both *ymin* and *bottom* or *ymax* and *top*.
+
+        Returns
+        -------
+        bottom, top : (float, float)
+            The new y-axis limits in data coordinates.
+
+        See Also
+        --------
+        get_ylim
+        set_ybound, get_ybound
+        invert_yaxis, yaxis_inverted
+
+        Notes
+        -----
+        The *bottom* value may be greater than the *top* value, in which
+        case the y-axis values will decrease from *bottom* to *top*.
+
+        Examples
+        --------
+        >>> set_ylim(bottom, top)
+        >>> set_ylim((bottom, top))
+        >>> bottom, top = set_ylim(bottom, top)
+
+        One limit may be left unchanged.
+
+        >>> set_ylim(top=top_lim)
+
+        Limits may be passed in reverse order to flip the direction of
+        the y-axis. For example, suppose ``y`` represents depth of the
+        ocean in m. The y-axis limits might be set like the following
+        so 5000 m depth is at the bottom of the plot and the surface,
+        0 m, is at the top.
+
+        >>> set_ylim(5000, 0)
+        """
+        return self._set_lim3d(self.yaxis, bottom, top, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=ymin, axmax=ymax)
+
+    def set_zlim(self, bottom=None, top=None, *, emit=True, auto=False,
+                 view_margin=None, zmin=None, zmax=None):
+        """
+        Set the 3D z-axis view limits.
+
+        Parameters
+        ----------
+        bottom : float, optional
+            The bottom zlim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+            The bottom and top zlims may also be passed as the tuple
+            (*bottom*, *top*) as the first positional argument (or as
+            the *bottom* keyword argument).
+
+            .. ACCEPTS: (bottom: float, top: float)
+
+        top : float, optional
+            The top zlim in data coordinates. Passing *None* leaves the
+            limit unchanged.
+
+        emit : bool, default: True
+            Whether to notify observers of limit change.
+
+        auto : bool or None, default: False
+            Whether to turn on autoscaling of the z-axis. *True* turns on,
+            *False* turns off, *None* leaves unchanged.
+
+        view_margin : float, optional
+            The additional margin to apply to the limits.
+
+        zmin, zmax : float, optional
+            They are equivalent to bottom and top respectively, and it is an
+            error to pass both *zmin* and *bottom* or *zmax* and *top*.
+
+        Returns
+        -------
+        bottom, top : (float, float)
+            The new z-axis limits in data coordinates.
+
+        See Also
+        --------
+        get_zlim
+        set_zbound, get_zbound
+        invert_zaxis, zaxis_inverted
+
+        Notes
+        -----
+        The *bottom* value may be greater than the *top* value, in which
+        case the z-axis values will decrease from *bottom* to *top*.
+
+        Examples
+        --------
+        >>> set_zlim(bottom, top)
+        >>> set_zlim((bottom, top))
+        >>> bottom, top = set_zlim(bottom, top)
+
+        One limit may be left unchanged.
+
+        >>> set_zlim(top=top_lim)
+
+        Limits may be passed in reverse order to flip the direction of
+        the z-axis. For example, suppose ``z`` represents depth of the
+        ocean in m. The z-axis limits might be set like the following
+        so 5000 m depth is at the bottom of the plot and the surface,
+        0 m, is at the top.
+
+        >>> set_zlim(5000, 0)
+        """
+        return self._set_lim3d(self.zaxis, bottom, top, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=zmin, axmax=zmax)
+
+    set_xlim3d = set_xlim
+    set_ylim3d = set_ylim
+    set_zlim3d = set_zlim
+
+    def get_xlim(self):
+        # docstring inherited
+        return tuple(self.xy_viewLim.intervalx)
+
+    def get_ylim(self):
+        # docstring inherited
+        return tuple(self.xy_viewLim.intervaly)
+
+    def get_zlim(self):
+        """
+        Return the 3D z-axis view limits.
+
+        Returns
+        -------
+        left, right : (float, float)
+            The current z-axis limits in data coordinates.
+
+        See Also
+        --------
+        set_zlim
+        set_zbound, get_zbound
+        invert_zaxis, zaxis_inverted
+
+        Notes
+        -----
+        The z-axis may be inverted, in which case the *left* value will
+        be greater than the *right* value.
+        """
+        return tuple(self.zz_viewLim.intervalx)
+
+    get_zscale = _axis_method_wrapper("zaxis", "get_scale")
+
+    # Redefine all three methods to overwrite their docstrings.
+    set_xscale = _axis_method_wrapper("xaxis", "_set_axes_scale")
+    set_yscale = _axis_method_wrapper("yaxis", "_set_axes_scale")
+    set_zscale = _axis_method_wrapper("zaxis", "_set_axes_scale")
+    set_xscale.__doc__, set_yscale.__doc__, set_zscale.__doc__ = map(
+        """
+        Set the {}-axis scale.
+
+        Parameters
+        ----------
+        value : {{"linear"}}
+            The axis scale type to apply.  3D Axes currently only support
+            linear scales; other scales yield nonsensical results.
+
+        **kwargs
+            Keyword arguments are nominally forwarded to the scale class, but
+            none of them is applicable for linear scales.
+        """.format,
+        ["x", "y", "z"])
+
+    get_zticks = _axis_method_wrapper("zaxis", "get_ticklocs")
+    set_zticks = _axis_method_wrapper("zaxis", "set_ticks")
+    get_zmajorticklabels = _axis_method_wrapper("zaxis", "get_majorticklabels")
+    get_zminorticklabels = _axis_method_wrapper("zaxis", "get_minorticklabels")
+    get_zticklabels = _axis_method_wrapper("zaxis", "get_ticklabels")
+    set_zticklabels = _axis_method_wrapper(
+        "zaxis", "set_ticklabels",
+        doc_sub={"Axis.set_ticks": "Axes3D.set_zticks"})
+
+    zaxis_date = _axis_method_wrapper("zaxis", "axis_date")
+    if zaxis_date.__doc__:
+        zaxis_date.__doc__ += textwrap.dedent("""
+
+        Notes
+        -----
+        This function is merely provided for completeness, but 3D Axes do not
+        support dates for ticks, and so this may not work as expected.
+        """)
+
+    def clabel(self, *args, **kwargs):
+        """Currently not implemented for 3D Axes, and returns *None*."""
+        return None
+
+    def view_init(self, elev=None, azim=None, roll=None, vertical_axis="z",
+                  share=False):
+        """
+        Set the elevation and azimuth of the Axes in degrees (not radians).
+
+        This can be used to rotate the Axes programmatically.
+
+        To look normal to the primary planes, the following elevation and
+        azimuth angles can be used. A roll angle of 0, 90, 180, or 270 deg
+        will rotate these views while keeping the axes at right angles.
+
+        ==========   ====  ====
+        view plane   elev  azim
+        ==========   ====  ====
+        XY           90    -90
+        XZ           0     -90
+        YZ           0     0
+        -XY          -90   90
+        -XZ          0     90
+        -YZ          0     180
+        ==========   ====  ====
+
+        Parameters
+        ----------
+        elev : float, default: None
+            The elevation angle in degrees rotates the camera above the plane
+            pierced by the vertical axis, with a positive angle corresponding
+            to a location above that plane. For example, with the default
+            vertical axis of 'z', the elevation defines the angle of the camera
+            location above the x-y plane.
+            If None, then the initial value as specified in the `Axes3D`
+            constructor is used.
+        azim : float, default: None
+            The azimuthal angle in degrees rotates the camera about the
+            vertical axis, with a positive angle corresponding to a
+            right-handed rotation. For example, with the default vertical axis
+            of 'z', a positive azimuth rotates the camera about the origin from
+            its location along the +x axis towards the +y axis.
+            If None, then the initial value as specified in the `Axes3D`
+            constructor is used.
+        roll : float, default: None
+            The roll angle in degrees rotates the camera about the viewing
+            axis. A positive angle spins the camera clockwise, causing the
+            scene to rotate counter-clockwise.
+            If None, then the initial value as specified in the `Axes3D`
+            constructor is used.
+        vertical_axis : {"z", "x", "y"}, default: "z"
+            The axis to align vertically. *azim* rotates about this axis.
+        share : bool, default: False
+            If ``True``, apply the settings to all Axes with shared views.
+        """
+
+        self._dist = 10  # The camera distance from origin. Behaves like zoom
+
+        if elev is None:
+            elev = self.initial_elev
+        if azim is None:
+            azim = self.initial_azim
+        if roll is None:
+            roll = self.initial_roll
+        vertical_axis = _api.check_getitem(
+            {name: idx for idx, name in enumerate(self._axis_names)},
+            vertical_axis=vertical_axis,
+        )
+
+        if share:
+            axes = {sibling for sibling
+                    in self._shared_axes['view'].get_siblings(self)}
+        else:
+            axes = [self]
+
+        for ax in axes:
+            ax.elev = elev
+            ax.azim = azim
+            ax.roll = roll
+            ax._vertical_axis = vertical_axis
+
+    def set_proj_type(self, proj_type, focal_length=None):
+        """
+        Set the projection type.
+
+        Parameters
+        ----------
+        proj_type : {'persp', 'ortho'}
+            The projection type.
+        focal_length : float, default: None
+            For a projection type of 'persp', the focal length of the virtual
+            camera. Must be > 0. If None, defaults to 1.
+            The focal length can be computed from a desired Field Of View via
+            the equation: focal_length = 1/tan(FOV/2)
+        """
+        _api.check_in_list(['persp', 'ortho'], proj_type=proj_type)
+        if proj_type == 'persp':
+            if focal_length is None:
+                focal_length = 1
+            elif focal_length <= 0:
+                raise ValueError(f"focal_length = {focal_length} must be "
+                                 "greater than 0")
+            self._focal_length = focal_length
+        else:  # 'ortho':
+            if focal_length not in (None, np.inf):
+                raise ValueError(f"focal_length = {focal_length} must be "
+                                 f"None for proj_type = {proj_type}")
+            self._focal_length = np.inf
+
+    def _roll_to_vertical(
+        self, arr: "np.typing.ArrayLike", reverse: bool = False
+    ) -> np.ndarray:
+        """
+        Roll arrays to match the different vertical axis.
+
+        Parameters
+        ----------
+        arr : ArrayLike
+            Array to roll.
+        reverse : bool, default: False
+            Reverse the direction of the roll.
+        """
+        if reverse:
+            return np.roll(arr, (self._vertical_axis - 2) * -1)
+        else:
+            return np.roll(arr, (self._vertical_axis - 2))
+
+    def get_proj(self):
+        """Create the projection matrix from the current viewing position."""
+
+        # Transform to uniform world coordinates 0-1, 0-1, 0-1
+        box_aspect = self._roll_to_vertical(self._box_aspect)
+        worldM = proj3d.world_transformation(
+            *self.get_xlim3d(),
+            *self.get_ylim3d(),
+            *self.get_zlim3d(),
+            pb_aspect=box_aspect,
+        )
+
+        # Look into the middle of the world coordinates:
+        R = 0.5 * box_aspect
+
+        # elev: elevation angle in the z plane.
+        # azim: azimuth angle in the xy plane.
+        # Coordinates for a point that rotates around the box of data.
+        # p0, p1 corresponds to rotating the box only around the vertical axis.
+        # p2 corresponds to rotating the box only around the horizontal axis.
+        elev_rad = np.deg2rad(self.elev)
+        azim_rad = np.deg2rad(self.azim)
+        p0 = np.cos(elev_rad) * np.cos(azim_rad)
+        p1 = np.cos(elev_rad) * np.sin(azim_rad)
+        p2 = np.sin(elev_rad)
+
+        # When changing vertical axis the coordinates changes as well.
+        # Roll the values to get the same behaviour as the default:
+        ps = self._roll_to_vertical([p0, p1, p2])
+
+        # The coordinates for the eye viewing point. The eye is looking
+        # towards the middle of the box of data from a distance:
+        eye = R + self._dist * ps
+
+        # Calculate the viewing axes for the eye position
+        u, v, w = self._calc_view_axes(eye)
+        self._view_u = u  # _view_u is towards the right of the screen
+        self._view_v = v  # _view_v is towards the top of the screen
+        self._view_w = w  # _view_w is out of the screen
+
+        # Generate the view and projection transformation matrices
+        if self._focal_length == np.inf:
+            # Orthographic projection
+            viewM = proj3d._view_transformation_uvw(u, v, w, eye)
+            projM = proj3d._ortho_transformation(-self._dist, self._dist)
+        else:
+            # Perspective projection
+            # Scale the eye dist to compensate for the focal length zoom effect
+            eye_focal = R + self._dist * ps * self._focal_length
+            viewM = proj3d._view_transformation_uvw(u, v, w, eye_focal)
+            projM = proj3d._persp_transformation(-self._dist,
+                                                 self._dist,
+                                                 self._focal_length)
+
+        # Combine all the transformation matrices to get the final projection
+        M0 = np.dot(viewM, worldM)
+        M = np.dot(projM, M0)
+        return M
+
+    def mouse_init(self, rotate_btn=1, pan_btn=2, zoom_btn=3):
+        """
+        Set the mouse buttons for 3D rotation and zooming.
+
+        Parameters
+        ----------
+        rotate_btn : int or list of int, default: 1
+            The mouse button or buttons to use for 3D rotation of the Axes.
+        pan_btn : int or list of int, default: 2
+            The mouse button or buttons to use to pan the 3D Axes.
+        zoom_btn : int or list of int, default: 3
+            The mouse button or buttons to use to zoom the 3D Axes.
+        """
+        self.button_pressed = None
+        # coerce scalars into array-like, then convert into
+        # a regular list to avoid comparisons against None
+        # which breaks in recent versions of numpy.
+        self._rotate_btn = np.atleast_1d(rotate_btn).tolist()
+        self._pan_btn = np.atleast_1d(pan_btn).tolist()
+        self._zoom_btn = np.atleast_1d(zoom_btn).tolist()
+
+    def disable_mouse_rotation(self):
+        """Disable mouse buttons for 3D rotation, panning, and zooming."""
+        self.mouse_init(rotate_btn=[], pan_btn=[], zoom_btn=[])
+
+    def can_zoom(self):
+        # doc-string inherited
+        return True
+
+    def can_pan(self):
+        # doc-string inherited
+        return True
+
+    def sharez(self, other):
+        """
+        Share the z-axis with *other*.
+
+        This is equivalent to passing ``sharez=other`` when constructing the
+        Axes, and cannot be used if the z-axis is already being shared with
+        another Axes.  Note that it is not possible to unshare axes.
+        """
+        _api.check_isinstance(Axes3D, other=other)
+        if self._sharez is not None and other is not self._sharez:
+            raise ValueError("z-axis is already shared")
+        self._shared_axes["z"].join(self, other)
+        self._sharez = other
+        self.zaxis.major = other.zaxis.major  # Ticker instances holding
+        self.zaxis.minor = other.zaxis.minor  # locator and formatter.
+        z0, z1 = other.get_zlim()
+        self.set_zlim(z0, z1, emit=False, auto=other.get_autoscalez_on())
+        self.zaxis._scale = other.zaxis._scale
+
+    def shareview(self, other):
+        """
+        Share the view angles with *other*.
+
+        This is equivalent to passing ``shareview=other`` when constructing the
+        Axes, and cannot be used if the view angles are already being shared
+        with another Axes.  Note that it is not possible to unshare axes.
+        """
+        _api.check_isinstance(Axes3D, other=other)
+        if self._shareview is not None and other is not self._shareview:
+            raise ValueError("view angles are already shared")
+        self._shared_axes["view"].join(self, other)
+        self._shareview = other
+        vertical_axis = self._axis_names[other._vertical_axis]
+        self.view_init(elev=other.elev, azim=other.azim, roll=other.roll,
+                       vertical_axis=vertical_axis, share=True)
+
+    def clear(self):
+        # docstring inherited.
+        super().clear()
+        if self._focal_length == np.inf:
+            self._zmargin = mpl.rcParams['axes.zmargin']
+        else:
+            self._zmargin = 0.
+
+        xymargin = 0.05 * 10/11  # match mpl3.8 appearance
+        self.xy_dataLim = Bbox([[xymargin, xymargin],
+                                [1 - xymargin, 1 - xymargin]])
+        # z-limits are encoded in the x-component of the Bbox, y is un-used
+        self.zz_dataLim = Bbox.unit()
+        self._view_margin = 1/48  # default value to match mpl3.8
+        self.autoscale_view()
+
+        self.grid(mpl.rcParams['axes3d.grid'])
+
+    def _button_press(self, event):
+        if event.inaxes == self:
+            self.button_pressed = event.button
+            self._sx, self._sy = event.xdata, event.ydata
+            toolbar = self.figure.canvas.toolbar
+            if toolbar and toolbar._nav_stack() is None:
+                toolbar.push_current()
+
+    def _button_release(self, event):
+        self.button_pressed = None
+        toolbar = self.figure.canvas.toolbar
+        # backend_bases.release_zoom and backend_bases.release_pan call
+        # push_current, so check the navigation mode so we don't call it twice
+        if toolbar and self.get_navigate_mode() is None:
+            toolbar.push_current()
+
+    def _get_view(self):
+        # docstring inherited
+        return {
+            "xlim": self.get_xlim(), "autoscalex_on": self.get_autoscalex_on(),
+            "ylim": self.get_ylim(), "autoscaley_on": self.get_autoscaley_on(),
+            "zlim": self.get_zlim(), "autoscalez_on": self.get_autoscalez_on(),
+        }, (self.elev, self.azim, self.roll)
+
+    def _set_view(self, view):
+        # docstring inherited
+        props, (elev, azim, roll) = view
+        self.set(**props)
+        self.elev = elev
+        self.azim = azim
+        self.roll = roll
+
+    def format_zdata(self, z):
+        """
+        Return *z* string formatted.  This function will use the
+        :attr:`fmt_zdata` attribute if it is callable, else will fall
+        back on the zaxis major formatter
+        """
+        try:
+            return self.fmt_zdata(z)
+        except (AttributeError, TypeError):
+            func = self.zaxis.get_major_formatter().format_data_short
+            val = func(z)
+            return val
+
+    def format_coord(self, xv, yv, renderer=None):
+        """
+        Return a string giving the current view rotation angles, or the x, y, z
+        coordinates of the point on the nearest axis pane underneath the mouse
+        cursor, depending on the mouse button pressed.
+        """
+        coords = ''
+
+        if self.button_pressed in self._rotate_btn:
+            # ignore xv and yv and display angles instead
+            coords = self._rotation_coords()
+
+        elif self.M is not None:
+            coords = self._location_coords(xv, yv, renderer)
+
+        return coords
+
+    def _rotation_coords(self):
+        """
+        Return the rotation angles as a string.
+        """
+        norm_elev = art3d._norm_angle(self.elev)
+        norm_azim = art3d._norm_angle(self.azim)
+        norm_roll = art3d._norm_angle(self.roll)
+        coords = (f"elevation={norm_elev:.0f}\N{DEGREE SIGN}, "
+                  f"azimuth={norm_azim:.0f}\N{DEGREE SIGN}, "
+                  f"roll={norm_roll:.0f}\N{DEGREE SIGN}"
+                  ).replace("-", "\N{MINUS SIGN}")
+        return coords
+
+    def _location_coords(self, xv, yv, renderer):
+        """
+        Return the location on the axis pane underneath the cursor as a string.
+        """
+        p1, pane_idx = self._calc_coord(xv, yv, renderer)
+        xs = self.format_xdata(p1[0])
+        ys = self.format_ydata(p1[1])
+        zs = self.format_zdata(p1[2])
+        if pane_idx == 0:
+            coords = f'x pane={xs}, y={ys}, z={zs}'
+        elif pane_idx == 1:
+            coords = f'x={xs}, y pane={ys}, z={zs}'
+        elif pane_idx == 2:
+            coords = f'x={xs}, y={ys}, z pane={zs}'
+        return coords
+
+    def _get_camera_loc(self):
+        """
+        Returns the current camera location in data coordinates.
+        """
+        cx, cy, cz, dx, dy, dz = self._get_w_centers_ranges()
+        c = np.array([cx, cy, cz])
+        r = np.array([dx, dy, dz])
+
+        if self._focal_length == np.inf:  # orthographic projection
+            focal_length = 1e9  # large enough to be effectively infinite
+        else:  # perspective projection
+            focal_length = self._focal_length
+        eye = c + self._view_w * self._dist * r / self._box_aspect * focal_length
+        return eye
+
+    def _calc_coord(self, xv, yv, renderer=None):
+        """
+        Given the 2D view coordinates, find the point on the nearest axis pane
+        that lies directly below those coordinates. Returns a 3D point in data
+        coordinates.
+        """
+        if self._focal_length == np.inf:  # orthographic projection
+            zv = 1
+        else:  # perspective projection
+            zv = -1 / self._focal_length
+
+        # Convert point on view plane to data coordinates
+        p1 = np.array(proj3d.inv_transform(xv, yv, zv, self.invM)).ravel()
+
+        # Get the vector from the camera to the point on the view plane
+        vec = self._get_camera_loc() - p1
+
+        # Get the pane locations for each of the axes
+        pane_locs = []
+        for axis in self._axis_map.values():
+            xys, loc = axis.active_pane()
+            pane_locs.append(loc)
+
+        # Find the distance to the nearest pane by projecting the view vector
+        scales = np.zeros(3)
+        for i in range(3):
+            if vec[i] == 0:
+                scales[i] = np.inf
+            else:
+                scales[i] = (p1[i] - pane_locs[i]) / vec[i]
+        pane_idx = np.argmin(abs(scales))
+        scale = scales[pane_idx]
+
+        # Calculate the point on the closest pane
+        p2 = p1 - scale*vec
+        return p2, pane_idx
+
+    def _on_move(self, event):
+        """
+        Mouse moving.
+
+        By default, button-1 rotates, button-2 pans, and button-3 zooms;
+        these buttons can be modified via `mouse_init`.
+        """
+
+        if not self.button_pressed:
+            return
+
+        if self.get_navigate_mode() is not None:
+            # we don't want to rotate if we are zooming/panning
+            # from the toolbar
+            return
+
+        if self.M is None:
+            return
+
+        x, y = event.xdata, event.ydata
+        # In case the mouse is out of bounds.
+        if x is None or event.inaxes != self:
+            return
+
+        dx, dy = x - self._sx, y - self._sy
+        w = self._pseudo_w
+        h = self._pseudo_h
+
+        # Rotation
+        if self.button_pressed in self._rotate_btn:
+            # rotate viewing point
+            # get the x and y pixel coords
+            if dx == 0 and dy == 0:
+                return
+
+            roll = np.deg2rad(self.roll)
+            delev = -(dy/h)*180*np.cos(roll) + (dx/w)*180*np.sin(roll)
+            dazim = -(dy/h)*180*np.sin(roll) - (dx/w)*180*np.cos(roll)
+            elev = self.elev + delev
+            azim = self.azim + dazim
+            roll = self.roll
+            vertical_axis = self._axis_names[self._vertical_axis]
+            self.view_init(
+                elev=elev,
+                azim=azim,
+                roll=roll,
+                vertical_axis=vertical_axis,
+                share=True,
+            )
+            self.stale = True
+
+        # Pan
+        elif self.button_pressed in self._pan_btn:
+            # Start the pan event with pixel coordinates
+            px, py = self.transData.transform([self._sx, self._sy])
+            self.start_pan(px, py, 2)
+            # pan view (takes pixel coordinate input)
+            self.drag_pan(2, None, event.x, event.y)
+            self.end_pan()
+
+        # Zoom
+        elif self.button_pressed in self._zoom_btn:
+            # zoom view (dragging down zooms in)
+            scale = h/(h - dy)
+            self._scale_axis_limits(scale, scale, scale)
+
+        # Store the event coordinates for the next time through.
+        self._sx, self._sy = x, y
+        # Always request a draw update at the end of interaction
+        self.figure.canvas.draw_idle()
+
+    def drag_pan(self, button, key, x, y):
+        # docstring inherited
+
+        # Get the coordinates from the move event
+        p = self._pan_start
+        (xdata, ydata), (xdata_start, ydata_start) = p.trans_inverse.transform(
+            [(x, y), (p.x, p.y)])
+        self._sx, self._sy = xdata, ydata
+        # Calling start_pan() to set the x/y of this event as the starting
+        # move location for the next event
+        self.start_pan(x, y, button)
+        du, dv = xdata - xdata_start, ydata - ydata_start
+        dw = 0
+        if key == 'x':
+            dv = 0
+        elif key == 'y':
+            du = 0
+        if du == 0 and dv == 0:
+            return
+
+        # Transform the pan from the view axes to the data axes
+        R = np.array([self._view_u, self._view_v, self._view_w])
+        R = -R / self._box_aspect * self._dist
+        duvw_projected = R.T @ np.array([du, dv, dw])
+
+        # Calculate pan distance
+        minx, maxx, miny, maxy, minz, maxz = self.get_w_lims()
+        dx = (maxx - minx) * duvw_projected[0]
+        dy = (maxy - miny) * duvw_projected[1]
+        dz = (maxz - minz) * duvw_projected[2]
+
+        # Set the new axis limits
+        self.set_xlim3d(minx + dx, maxx + dx, auto=None)
+        self.set_ylim3d(miny + dy, maxy + dy, auto=None)
+        self.set_zlim3d(minz + dz, maxz + dz, auto=None)
+
+    def _calc_view_axes(self, eye):
+        """
+        Get the unit vectors for the viewing axes in data coordinates.
+        `u` is towards the right of the screen
+        `v` is towards the top of the screen
+        `w` is out of the screen
+        """
+        elev_rad = np.deg2rad(art3d._norm_angle(self.elev))
+        roll_rad = np.deg2rad(art3d._norm_angle(self.roll))
+
+        # Look into the middle of the world coordinates
+        R = 0.5 * self._roll_to_vertical(self._box_aspect)
+
+        # Define which axis should be vertical. A negative value
+        # indicates the plot is upside down and therefore the values
+        # have been reversed:
+        V = np.zeros(3)
+        V[self._vertical_axis] = -1 if abs(elev_rad) > np.pi/2 else 1
+
+        u, v, w = proj3d._view_axes(eye, R, V, roll_rad)
+        return u, v, w
+
+    def _set_view_from_bbox(self, bbox, direction='in',
+                            mode=None, twinx=False, twiny=False):
+        """
+        Zoom in or out of the bounding box.
+
+        Will center the view in the center of the bounding box, and zoom by
+        the ratio of the size of the bounding box to the size of the Axes3D.
+        """
+        (start_x, start_y, stop_x, stop_y) = bbox
+        if mode == 'x':
+            start_y = self.bbox.min[1]
+            stop_y = self.bbox.max[1]
+        elif mode == 'y':
+            start_x = self.bbox.min[0]
+            stop_x = self.bbox.max[0]
+
+        # Clip to bounding box limits
+        start_x, stop_x = np.clip(sorted([start_x, stop_x]),
+                                  self.bbox.min[0], self.bbox.max[0])
+        start_y, stop_y = np.clip(sorted([start_y, stop_y]),
+                                  self.bbox.min[1], self.bbox.max[1])
+
+        # Move the center of the view to the center of the bbox
+        zoom_center_x = (start_x + stop_x)/2
+        zoom_center_y = (start_y + stop_y)/2
+
+        ax_center_x = (self.bbox.max[0] + self.bbox.min[0])/2
+        ax_center_y = (self.bbox.max[1] + self.bbox.min[1])/2
+
+        self.start_pan(zoom_center_x, zoom_center_y, 2)
+        self.drag_pan(2, None, ax_center_x, ax_center_y)
+        self.end_pan()
+
+        # Calculate zoom level
+        dx = abs(start_x - stop_x)
+        dy = abs(start_y - stop_y)
+        scale_u = dx / (self.bbox.max[0] - self.bbox.min[0])
+        scale_v = dy / (self.bbox.max[1] - self.bbox.min[1])
+
+        # Keep aspect ratios equal
+        scale = max(scale_u, scale_v)
+
+        # Zoom out
+        if direction == 'out':
+            scale = 1 / scale
+
+        self._zoom_data_limits(scale, scale, scale)
+
+    def _zoom_data_limits(self, scale_u, scale_v, scale_w):
+        """
+        Zoom in or out of a 3D plot.
+
+        Will scale the data limits by the scale factors. These will be
+        transformed to the x, y, z data axes based on the current view angles.
+        A scale factor > 1 zooms out and a scale factor < 1 zooms in.
+
+        For an Axes that has had its aspect ratio set to 'equal', 'equalxy',
+        'equalyz', or 'equalxz', the relevant axes are constrained to zoom
+        equally.
+
+        Parameters
+        ----------
+        scale_u : float
+            Scale factor for the u view axis (view screen horizontal).
+        scale_v : float
+            Scale factor for the v view axis (view screen vertical).
+        scale_w : float
+            Scale factor for the w view axis (view screen depth).
+        """
+        scale = np.array([scale_u, scale_v, scale_w])
+
+        # Only perform frame conversion if unequal scale factors
+        if not np.allclose(scale, scale_u):
+            # Convert the scale factors from the view frame to the data frame
+            R = np.array([self._view_u, self._view_v, self._view_w])
+            S = scale * np.eye(3)
+            scale = np.linalg.norm(R.T @ S, axis=1)
+
+            # Set the constrained scale factors to the factor closest to 1
+            if self._aspect in ('equal', 'equalxy', 'equalxz', 'equalyz'):
+                ax_idxs = self._equal_aspect_axis_indices(self._aspect)
+                min_ax_idxs = np.argmin(np.abs(scale[ax_idxs] - 1))
+                scale[ax_idxs] = scale[ax_idxs][min_ax_idxs]
+
+        self._scale_axis_limits(scale[0], scale[1], scale[2])
+
+    def _scale_axis_limits(self, scale_x, scale_y, scale_z):
+        """
+        Keeping the center of the x, y, and z data axes fixed, scale their
+        limits by scale factors. A scale factor > 1 zooms out and a scale
+        factor < 1 zooms in.
+
+        Parameters
+        ----------
+        scale_x : float
+            Scale factor for the x data axis.
+        scale_y : float
+            Scale factor for the y data axis.
+        scale_z : float
+            Scale factor for the z data axis.
+        """
+        # Get the axis centers and ranges
+        cx, cy, cz, dx, dy, dz = self._get_w_centers_ranges()
+
+        # Set the scaled axis limits
+        self.set_xlim3d(cx - dx*scale_x/2, cx + dx*scale_x/2, auto=None)
+        self.set_ylim3d(cy - dy*scale_y/2, cy + dy*scale_y/2, auto=None)
+        self.set_zlim3d(cz - dz*scale_z/2, cz + dz*scale_z/2, auto=None)
+
+    def _get_w_centers_ranges(self):
+        """Get 3D world centers and axis ranges."""
+        # Calculate center of axis limits
+        minx, maxx, miny, maxy, minz, maxz = self.get_w_lims()
+        cx = (maxx + minx)/2
+        cy = (maxy + miny)/2
+        cz = (maxz + minz)/2
+
+        # Calculate range of axis limits
+        dx = (maxx - minx)
+        dy = (maxy - miny)
+        dz = (maxz - minz)
+        return cx, cy, cz, dx, dy, dz
+
+    def set_zlabel(self, zlabel, fontdict=None, labelpad=None, **kwargs):
+        """
+        Set zlabel.  See doc for `.set_ylabel` for description.
+        """
+        if labelpad is not None:
+            self.zaxis.labelpad = labelpad
+        return self.zaxis.set_label_text(zlabel, fontdict, **kwargs)
+
+    def get_zlabel(self):
+        """
+        Get the z-label text string.
+        """
+        label = self.zaxis.get_label()
+        return label.get_text()
+
+    # Axes rectangle characteristics
+
+    # The frame_on methods are not available for 3D axes.
+    # Python will raise a TypeError if they are called.
+    get_frame_on = None
+    set_frame_on = None
+
+    def grid(self, visible=True, **kwargs):
+        """
+        Set / unset 3D grid.
+
+        .. note::
+
+            Currently, this function does not behave the same as
+            `.axes.Axes.grid`, but it is intended to eventually support that
+            behavior.
+        """
+        # TODO: Operate on each axes separately
+        if len(kwargs):
+            visible = True
+        self._draw_grid = visible
+        self.stale = True
+
+    def tick_params(self, axis='both', **kwargs):
+        """
+        Convenience method for changing the appearance of ticks and
+        tick labels.
+
+        See `.Axes.tick_params` for full documentation.  Because this function
+        applies to 3D Axes, *axis* can also be set to 'z', and setting *axis*
+        to 'both' autoscales all three axes.
+
+        Also, because of how Axes3D objects are drawn very differently
+        from regular 2D Axes, some of these settings may have
+        ambiguous meaning.  For simplicity, the 'z' axis will
+        accept settings as if it was like the 'y' axis.
+
+        .. note::
+           Axes3D currently ignores some of these settings.
+        """
+        _api.check_in_list(['x', 'y', 'z', 'both'], axis=axis)
+        if axis in ['x', 'y', 'both']:
+            super().tick_params(axis, **kwargs)
+        if axis in ['z', 'both']:
+            zkw = dict(kwargs)
+            zkw.pop('top', None)
+            zkw.pop('bottom', None)
+            zkw.pop('labeltop', None)
+            zkw.pop('labelbottom', None)
+            self.zaxis.set_tick_params(**zkw)
+
+    # data limits, ticks, tick labels, and formatting
+
+    def invert_zaxis(self):
+        """
+        Invert the z-axis.
+
+        See Also
+        --------
+        zaxis_inverted
+        get_zlim, set_zlim
+        get_zbound, set_zbound
+        """
+        bottom, top = self.get_zlim()
+        self.set_zlim(top, bottom, auto=None)
+
+    zaxis_inverted = _axis_method_wrapper("zaxis", "get_inverted")
+
+    def get_zbound(self):
+        """
+        Return the lower and upper z-axis bounds, in increasing order.
+
+        See Also
+        --------
+        set_zbound
+        get_zlim, set_zlim
+        invert_zaxis, zaxis_inverted
+        """
+        lower, upper = self.get_zlim()
+        if lower < upper:
+            return lower, upper
+        else:
+            return upper, lower
+
+    def text(self, x, y, z, s, zdir=None, **kwargs):
+        """
+        Add the text *s* to the 3D Axes at location *x*, *y*, *z* in data coordinates.
+
+        Parameters
+        ----------
+        x, y, z : float
+            The position to place the text.
+        s : str
+            The text.
+        zdir : {'x', 'y', 'z', 3-tuple}, optional
+            The direction to be used as the z-direction. Default: 'z'.
+            See `.get_dir_vector` for a description of the values.
+        **kwargs
+            Other arguments are forwarded to `matplotlib.axes.Axes.text`.
+
+        Returns
+        -------
+        `.Text3D`
+            The created `.Text3D` instance.
+        """
+        text = super().text(x, y, s, **kwargs)
+        art3d.text_2d_to_3d(text, z, zdir)
+        return text
+
+    text3D = text
+    text2D = Axes.text
+
+    def plot(self, xs, ys, *args, zdir='z', **kwargs):
+        """
+        Plot 2D or 3D data.
+
+        Parameters
+        ----------
+        xs : 1D array-like
+            x coordinates of vertices.
+        ys : 1D array-like
+            y coordinates of vertices.
+        zs : float or 1D array-like
+            z coordinates of vertices; either one for all points or one for
+            each point.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            When plotting 2D data, the direction to use as z.
+        **kwargs
+            Other arguments are forwarded to `matplotlib.axes.Axes.plot`.
+        """
+        had_data = self.has_data()
+
+        # `zs` can be passed positionally or as keyword; checking whether
+        # args[0] is a string matches the behavior of 2D `plot` (via
+        # `_process_plot_var_args`).
+        if args and not isinstance(args[0], str):
+            zs, *args = args
+            if 'zs' in kwargs:
+                raise TypeError("plot() for multiple values for argument 'zs'")
+        else:
+            zs = kwargs.pop('zs', 0)
+
+        xs, ys, zs = cbook._broadcast_with_masks(xs, ys, zs)
+
+        lines = super().plot(xs, ys, *args, **kwargs)
+        for line in lines:
+            art3d.line_2d_to_3d(line, zs=zs, zdir=zdir)
+
+        xs, ys, zs = art3d.juggle_axes(xs, ys, zs, zdir)
+        self.auto_scale_xyz(xs, ys, zs, had_data)
+        return lines
+
+    plot3D = plot
+
+    def plot_surface(self, X, Y, Z, *, norm=None, vmin=None,
+                     vmax=None, lightsource=None, **kwargs):
+        """
+        Create a surface plot.
+
+        By default, it will be colored in shades of a solid color, but it also
+        supports colormapping by supplying the *cmap* argument.
+
+        .. note::
+
+           The *rcount* and *ccount* kwargs, which both default to 50,
+           determine the maximum number of samples used in each direction.  If
+           the input data is larger, it will be downsampled (by slicing) to
+           these numbers of points.
+
+        .. note::
+
+           To maximize rendering speed consider setting *rstride* and *cstride*
+           to divisors of the number of rows minus 1 and columns minus 1
+           respectively. For example, given 51 rows rstride can be any of the
+           divisors of 50.
+
+           Similarly, a setting of *rstride* and *cstride* equal to 1 (or
+           *rcount* and *ccount* equal the number of rows and columns) can use
+           the optimized path.
+
+        Parameters
+        ----------
+        X, Y, Z : 2D arrays
+            Data values.
+
+        rcount, ccount : int
+            Maximum number of samples used in each direction.  If the input
+            data is larger, it will be downsampled (by slicing) to these
+            numbers of points.  Defaults to 50.
+
+        rstride, cstride : int
+            Downsampling stride in each direction.  These arguments are
+            mutually exclusive with *rcount* and *ccount*.  If only one of
+            *rstride* or *cstride* is set, the other defaults to 10.
+
+            'classic' mode uses a default of ``rstride = cstride = 10`` instead
+            of the new default of ``rcount = ccount = 50``.
+
+        color : :mpltype:`color`
+            Color of the surface patches.
+
+        cmap : Colormap, optional
+            Colormap of the surface patches.
+
+        facecolors : list of :mpltype:`color`
+            Colors of each individual patch.
+
+        norm : `~matplotlib.colors.Normalize`, optional
+            Normalization for the colormap.
+
+        vmin, vmax : float, optional
+            Bounds for the normalization.
+
+        shade : bool, default: True
+            Whether to shade the facecolors.  Shading is always disabled when
+            *cmap* is specified.
+
+        lightsource : `~matplotlib.colors.LightSource`, optional
+            The lightsource to use when *shade* is True.
+
+        **kwargs
+            Other keyword arguments are forwarded to `.Poly3DCollection`.
+        """
+
+        had_data = self.has_data()
+
+        if Z.ndim != 2:
+            raise ValueError("Argument Z must be 2-dimensional.")
+
+        Z = cbook._to_unmasked_float_array(Z)
+        X, Y, Z = np.broadcast_arrays(X, Y, Z)
+        rows, cols = Z.shape
+
+        has_stride = 'rstride' in kwargs or 'cstride' in kwargs
+        has_count = 'rcount' in kwargs or 'ccount' in kwargs
+
+        if has_stride and has_count:
+            raise ValueError("Cannot specify both stride and count arguments")
+
+        rstride = kwargs.pop('rstride', 10)
+        cstride = kwargs.pop('cstride', 10)
+        rcount = kwargs.pop('rcount', 50)
+        ccount = kwargs.pop('ccount', 50)
+
+        if mpl.rcParams['_internal.classic_mode']:
+            # Strides have priority over counts in classic mode.
+            # So, only compute strides from counts
+            # if counts were explicitly given
+            compute_strides = has_count
+        else:
+            # If the strides are provided then it has priority.
+            # Otherwise, compute the strides from the counts.
+            compute_strides = not has_stride
+
+        if compute_strides:
+            rstride = int(max(np.ceil(rows / rcount), 1))
+            cstride = int(max(np.ceil(cols / ccount), 1))
+
+        fcolors = kwargs.pop('facecolors', None)
+
+        cmap = kwargs.get('cmap', None)
+        shade = kwargs.pop('shade', cmap is None)
+        if shade is None:
+            raise ValueError("shade cannot be None.")
+
+        colset = []  # the sampled facecolor
+        if (rows - 1) % rstride == 0 and \
+           (cols - 1) % cstride == 0 and \
+           fcolors is None:
+            polys = np.stack(
+                [cbook._array_patch_perimeters(a, rstride, cstride)
+                 for a in (X, Y, Z)],
+                axis=-1)
+        else:
+            # evenly spaced, and including both endpoints
+            row_inds = list(range(0, rows-1, rstride)) + [rows-1]
+            col_inds = list(range(0, cols-1, cstride)) + [cols-1]
+
+            polys = []
+            for rs, rs_next in zip(row_inds[:-1], row_inds[1:]):
+                for cs, cs_next in zip(col_inds[:-1], col_inds[1:]):
+                    ps = [
+                        # +1 ensures we share edges between polygons
+                        cbook._array_perimeter(a[rs:rs_next+1, cs:cs_next+1])
+                        for a in (X, Y, Z)
+                    ]
+                    # ps = np.stack(ps, axis=-1)
+                    ps = np.array(ps).T
+                    polys.append(ps)
+
+                    if fcolors is not None:
+                        colset.append(fcolors[rs][cs])
+
+        # In cases where there are non-finite values in the data (possibly NaNs from
+        # masked arrays), artifacts can be introduced. Here check whether such values
+        # are present and remove them.
+        if not isinstance(polys, np.ndarray) or not np.isfinite(polys).all():
+            new_polys = []
+            new_colset = []
+
+            # Depending on fcolors, colset is either an empty list or has as
+            # many elements as polys. In the former case new_colset results in
+            # a list with None entries, that is discarded later.
+            for p, col in itertools.zip_longest(polys, colset):
+                new_poly = np.array(p)[np.isfinite(p).all(axis=1)]
+                if len(new_poly):
+                    new_polys.append(new_poly)
+                    new_colset.append(col)
+
+            # Replace previous polys and, if fcolors is not None, colset
+            polys = new_polys
+            if fcolors is not None:
+                colset = new_colset
+
+        # note that the striding causes some polygons to have more coordinates
+        # than others
+
+        if fcolors is not None:
+            polyc = art3d.Poly3DCollection(
+                polys, edgecolors=colset, facecolors=colset, shade=shade,
+                lightsource=lightsource, **kwargs)
+        elif cmap:
+            polyc = art3d.Poly3DCollection(polys, **kwargs)
+            # can't always vectorize, because polys might be jagged
+            if isinstance(polys, np.ndarray):
+                avg_z = polys[..., 2].mean(axis=-1)
+            else:
+                avg_z = np.array([ps[:, 2].mean() for ps in polys])
+            polyc.set_array(avg_z)
+            if vmin is not None or vmax is not None:
+                polyc.set_clim(vmin, vmax)
+            if norm is not None:
+                polyc.set_norm(norm)
+        else:
+            color = kwargs.pop('color', None)
+            if color is None:
+                color = self._get_lines.get_next_color()
+            color = np.array(mcolors.to_rgba(color))
+
+            polyc = art3d.Poly3DCollection(
+                polys, facecolors=color, shade=shade,
+                lightsource=lightsource, **kwargs)
+
+        self.add_collection(polyc)
+        self.auto_scale_xyz(X, Y, Z, had_data)
+
+        return polyc
+
+    def plot_wireframe(self, X, Y, Z, **kwargs):
+        """
+        Plot a 3D wireframe.
+
+        .. note::
+
+           The *rcount* and *ccount* kwargs, which both default to 50,
+           determine the maximum number of samples used in each direction.  If
+           the input data is larger, it will be downsampled (by slicing) to
+           these numbers of points.
+
+        Parameters
+        ----------
+        X, Y, Z : 2D arrays
+            Data values.
+
+        rcount, ccount : int
+            Maximum number of samples used in each direction.  If the input
+            data is larger, it will be downsampled (by slicing) to these
+            numbers of points.  Setting a count to zero causes the data to be
+            not sampled in the corresponding direction, producing a 3D line
+            plot rather than a wireframe plot.  Defaults to 50.
+
+        rstride, cstride : int
+            Downsampling stride in each direction.  These arguments are
+            mutually exclusive with *rcount* and *ccount*.  If only one of
+            *rstride* or *cstride* is set, the other defaults to 1.  Setting a
+            stride to zero causes the data to be not sampled in the
+            corresponding direction, producing a 3D line plot rather than a
+            wireframe plot.
+
+            'classic' mode uses a default of ``rstride = cstride = 1`` instead
+            of the new default of ``rcount = ccount = 50``.
+
+        **kwargs
+            Other keyword arguments are forwarded to `.Line3DCollection`.
+        """
+
+        had_data = self.has_data()
+        if Z.ndim != 2:
+            raise ValueError("Argument Z must be 2-dimensional.")
+        # FIXME: Support masked arrays
+        X, Y, Z = np.broadcast_arrays(X, Y, Z)
+        rows, cols = Z.shape
+
+        has_stride = 'rstride' in kwargs or 'cstride' in kwargs
+        has_count = 'rcount' in kwargs or 'ccount' in kwargs
+
+        if has_stride and has_count:
+            raise ValueError("Cannot specify both stride and count arguments")
+
+        rstride = kwargs.pop('rstride', 1)
+        cstride = kwargs.pop('cstride', 1)
+        rcount = kwargs.pop('rcount', 50)
+        ccount = kwargs.pop('ccount', 50)
+
+        if mpl.rcParams['_internal.classic_mode']:
+            # Strides have priority over counts in classic mode.
+            # So, only compute strides from counts
+            # if counts were explicitly given
+            if has_count:
+                rstride = int(max(np.ceil(rows / rcount), 1)) if rcount else 0
+                cstride = int(max(np.ceil(cols / ccount), 1)) if ccount else 0
+        else:
+            # If the strides are provided then it has priority.
+            # Otherwise, compute the strides from the counts.
+            if not has_stride:
+                rstride = int(max(np.ceil(rows / rcount), 1)) if rcount else 0
+                cstride = int(max(np.ceil(cols / ccount), 1)) if ccount else 0
+
+        # We want two sets of lines, one running along the "rows" of
+        # Z and another set of lines running along the "columns" of Z.
+        # This transpose will make it easy to obtain the columns.
+        tX, tY, tZ = np.transpose(X), np.transpose(Y), np.transpose(Z)
+
+        if rstride:
+            rii = list(range(0, rows, rstride))
+            # Add the last index only if needed
+            if rows > 0 and rii[-1] != (rows - 1):
+                rii += [rows-1]
+        else:
+            rii = []
+        if cstride:
+            cii = list(range(0, cols, cstride))
+            # Add the last index only if needed
+            if cols > 0 and cii[-1] != (cols - 1):
+                cii += [cols-1]
+        else:
+            cii = []
+
+        if rstride == 0 and cstride == 0:
+            raise ValueError("Either rstride or cstride must be non zero")
+
+        # If the inputs were empty, then just
+        # reset everything.
+        if Z.size == 0:
+            rii = []
+            cii = []
+
+        xlines = [X[i] for i in rii]
+        ylines = [Y[i] for i in rii]
+        zlines = [Z[i] for i in rii]
+
+        txlines = [tX[i] for i in cii]
+        tylines = [tY[i] for i in cii]
+        tzlines = [tZ[i] for i in cii]
+
+        lines = ([list(zip(xl, yl, zl))
+                 for xl, yl, zl in zip(xlines, ylines, zlines)]
+                 + [list(zip(xl, yl, zl))
+                 for xl, yl, zl in zip(txlines, tylines, tzlines)])
+
+        linec = art3d.Line3DCollection(lines, **kwargs)
+        self.add_collection(linec)
+        self.auto_scale_xyz(X, Y, Z, had_data)
+
+        return linec
+
+    def plot_trisurf(self, *args, color=None, norm=None, vmin=None, vmax=None,
+                     lightsource=None, **kwargs):
+        """
+        Plot a triangulated surface.
+
+        The (optional) triangulation can be specified in one of two ways;
+        either::
+
+          plot_trisurf(triangulation, ...)
+
+        where triangulation is a `~matplotlib.tri.Triangulation` object, or::
+
+          plot_trisurf(X, Y, ...)
+          plot_trisurf(X, Y, triangles, ...)
+          plot_trisurf(X, Y, triangles=triangles, ...)
+
+        in which case a Triangulation object will be created.  See
+        `.Triangulation` for an explanation of these possibilities.
+
+        The remaining arguments are::
+
+          plot_trisurf(..., Z)
+
+        where *Z* is the array of values to contour, one per point
+        in the triangulation.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like
+            Data values as 1D arrays.
+        color
+            Color of the surface patches.
+        cmap
+            A colormap for the surface patches.
+        norm : `~matplotlib.colors.Normalize`, optional
+            An instance of Normalize to map values to colors.
+        vmin, vmax : float, optional
+            Minimum and maximum value to map.
+        shade : bool, default: True
+            Whether to shade the facecolors.  Shading is always disabled when
+            *cmap* is specified.
+        lightsource : `~matplotlib.colors.LightSource`, optional
+            The lightsource to use when *shade* is True.
+        **kwargs
+            All other keyword arguments are passed on to
+            :class:`~mpl_toolkits.mplot3d.art3d.Poly3DCollection`
+
+        Examples
+        --------
+        .. plot:: gallery/mplot3d/trisurf3d.py
+        .. plot:: gallery/mplot3d/trisurf3d_2.py
+        """
+
+        had_data = self.has_data()
+
+        # TODO: Support custom face colours
+        if color is None:
+            color = self._get_lines.get_next_color()
+        color = np.array(mcolors.to_rgba(color))
+
+        cmap = kwargs.get('cmap', None)
+        shade = kwargs.pop('shade', cmap is None)
+
+        tri, args, kwargs = \
+            Triangulation.get_from_args_and_kwargs(*args, **kwargs)
+        try:
+            z = kwargs.pop('Z')
+        except KeyError:
+            # We do this so Z doesn't get passed as an arg to PolyCollection
+            z, *args = args
+        z = np.asarray(z)
+
+        triangles = tri.get_masked_triangles()
+        xt = tri.x[triangles]
+        yt = tri.y[triangles]
+        zt = z[triangles]
+        verts = np.stack((xt, yt, zt), axis=-1)
+
+        if cmap:
+            polyc = art3d.Poly3DCollection(verts, *args, **kwargs)
+            # average over the three points of each triangle
+            avg_z = verts[:, :, 2].mean(axis=1)
+            polyc.set_array(avg_z)
+            if vmin is not None or vmax is not None:
+                polyc.set_clim(vmin, vmax)
+            if norm is not None:
+                polyc.set_norm(norm)
+        else:
+            polyc = art3d.Poly3DCollection(
+                verts, *args, shade=shade, lightsource=lightsource,
+                facecolors=color, **kwargs)
+
+        self.add_collection(polyc)
+        self.auto_scale_xyz(tri.x, tri.y, z, had_data)
+
+        return polyc
+
+    def _3d_extend_contour(self, cset, stride=5):
+        """
+        Extend a contour in 3D by creating
+        """
+
+        dz = (cset.levels[1] - cset.levels[0]) / 2
+        polyverts = []
+        colors = []
+        for idx, level in enumerate(cset.levels):
+            path = cset.get_paths()[idx]
+            subpaths = [*path._iter_connected_components()]
+            color = cset.get_edgecolor()[idx]
+            top = art3d._paths_to_3d_segments(subpaths, level - dz)
+            bot = art3d._paths_to_3d_segments(subpaths, level + dz)
+            if not len(top[0]):
+                continue
+            nsteps = max(round(len(top[0]) / stride), 2)
+            stepsize = (len(top[0]) - 1) / (nsteps - 1)
+            polyverts.extend([
+                (top[0][round(i * stepsize)], top[0][round((i + 1) * stepsize)],
+                 bot[0][round((i + 1) * stepsize)], bot[0][round(i * stepsize)])
+                for i in range(round(nsteps) - 1)])
+            colors.extend([color] * (round(nsteps) - 1))
+        self.add_collection3d(art3d.Poly3DCollection(
+            np.array(polyverts),  # All polygons have 4 vertices, so vectorize.
+            facecolors=colors, edgecolors=colors, shade=True))
+        cset.remove()
+
+    def add_contour_set(
+            self, cset, extend3d=False, stride=5, zdir='z', offset=None):
+        zdir = '-' + zdir
+        if extend3d:
+            self._3d_extend_contour(cset, stride)
+        else:
+            art3d.collection_2d_to_3d(
+                cset, zs=offset if offset is not None else cset.levels, zdir=zdir)
+
+    def add_contourf_set(self, cset, zdir='z', offset=None):
+        self._add_contourf_set(cset, zdir=zdir, offset=offset)
+
+    def _add_contourf_set(self, cset, zdir='z', offset=None):
+        """
+        Returns
+        -------
+        levels : `numpy.ndarray`
+            Levels at which the filled contours are added.
+        """
+        zdir = '-' + zdir
+
+        midpoints = cset.levels[:-1] + np.diff(cset.levels) / 2
+        # Linearly interpolate to get levels for any extensions
+        if cset._extend_min:
+            min_level = cset.levels[0] - np.diff(cset.levels[:2]) / 2
+            midpoints = np.insert(midpoints, 0, min_level)
+        if cset._extend_max:
+            max_level = cset.levels[-1] + np.diff(cset.levels[-2:]) / 2
+            midpoints = np.append(midpoints, max_level)
+
+        art3d.collection_2d_to_3d(
+            cset, zs=offset if offset is not None else midpoints, zdir=zdir)
+        return midpoints
+
+    @_preprocess_data()
+    def contour(self, X, Y, Z, *args,
+                extend3d=False, stride=5, zdir='z', offset=None, **kwargs):
+        """
+        Create a 3D contour plot.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like,
+            Input data. See `.Axes.contour` for supported data shapes.
+        extend3d : bool, default: False
+            Whether to extend contour in 3D.
+        stride : int, default: 5
+            Step size for extending contour.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            The direction to use.
+        offset : float, optional
+            If specified, plot a projection of the contour lines at this
+            position in a plane normal to *zdir*.
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+
+        *args, **kwargs
+            Other arguments are forwarded to `matplotlib.axes.Axes.contour`.
+
+        Returns
+        -------
+        matplotlib.contour.QuadContourSet
+        """
+        had_data = self.has_data()
+
+        jX, jY, jZ = art3d.rotate_axes(X, Y, Z, zdir)
+        cset = super().contour(jX, jY, jZ, *args, **kwargs)
+        self.add_contour_set(cset, extend3d, stride, zdir, offset)
+
+        self.auto_scale_xyz(X, Y, Z, had_data)
+        return cset
+
+    contour3D = contour
+
+    @_preprocess_data()
+    def tricontour(self, *args,
+                   extend3d=False, stride=5, zdir='z', offset=None, **kwargs):
+        """
+        Create a 3D contour plot.
+
+        .. note::
+            This method currently produces incorrect output due to a
+            longstanding bug in 3D PolyCollection rendering.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like
+            Input data. See `.Axes.tricontour` for supported data shapes.
+        extend3d : bool, default: False
+            Whether to extend contour in 3D.
+        stride : int, default: 5
+            Step size for extending contour.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            The direction to use.
+        offset : float, optional
+            If specified, plot a projection of the contour lines at this
+            position in a plane normal to *zdir*.
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+        *args, **kwargs
+            Other arguments are forwarded to `matplotlib.axes.Axes.tricontour`.
+
+        Returns
+        -------
+        matplotlib.tri._tricontour.TriContourSet
+        """
+        had_data = self.has_data()
+
+        tri, args, kwargs = Triangulation.get_from_args_and_kwargs(
+                *args, **kwargs)
+        X = tri.x
+        Y = tri.y
+        if 'Z' in kwargs:
+            Z = kwargs.pop('Z')
+        else:
+            # We do this so Z doesn't get passed as an arg to Axes.tricontour
+            Z, *args = args
+
+        jX, jY, jZ = art3d.rotate_axes(X, Y, Z, zdir)
+        tri = Triangulation(jX, jY, tri.triangles, tri.mask)
+
+        cset = super().tricontour(tri, jZ, *args, **kwargs)
+        self.add_contour_set(cset, extend3d, stride, zdir, offset)
+
+        self.auto_scale_xyz(X, Y, Z, had_data)
+        return cset
+
+    def _auto_scale_contourf(self, X, Y, Z, zdir, levels, had_data):
+        # Autoscale in the zdir based on the levels added, which are
+        # different from data range if any contour extensions are present
+        dim_vals = {'x': X, 'y': Y, 'z': Z, zdir: levels}
+        # Input data and levels have different sizes, but auto_scale_xyz
+        # expected same-size input, so manually take min/max limits
+        limits = [(np.nanmin(dim_vals[dim]), np.nanmax(dim_vals[dim]))
+                  for dim in ['x', 'y', 'z']]
+        self.auto_scale_xyz(*limits, had_data)
+
+    @_preprocess_data()
+    def contourf(self, X, Y, Z, *args, zdir='z', offset=None, **kwargs):
+        """
+        Create a 3D filled contour plot.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like
+            Input data. See `.Axes.contourf` for supported data shapes.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            The direction to use.
+        offset : float, optional
+            If specified, plot a projection of the contour lines at this
+            position in a plane normal to *zdir*.
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+        *args, **kwargs
+            Other arguments are forwarded to `matplotlib.axes.Axes.contourf`.
+
+        Returns
+        -------
+        matplotlib.contour.QuadContourSet
+        """
+        had_data = self.has_data()
+
+        jX, jY, jZ = art3d.rotate_axes(X, Y, Z, zdir)
+        cset = super().contourf(jX, jY, jZ, *args, **kwargs)
+        levels = self._add_contourf_set(cset, zdir, offset)
+
+        self._auto_scale_contourf(X, Y, Z, zdir, levels, had_data)
+        return cset
+
+    contourf3D = contourf
+
+    @_preprocess_data()
+    def tricontourf(self, *args, zdir='z', offset=None, **kwargs):
+        """
+        Create a 3D filled contour plot.
+
+        .. note::
+            This method currently produces incorrect output due to a
+            longstanding bug in 3D PolyCollection rendering.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like
+            Input data. See `.Axes.tricontourf` for supported data shapes.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            The direction to use.
+        offset : float, optional
+            If specified, plot a projection of the contour lines at this
+            position in a plane normal to zdir.
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+        *args, **kwargs
+            Other arguments are forwarded to
+            `matplotlib.axes.Axes.tricontourf`.
+
+        Returns
+        -------
+        matplotlib.tri._tricontour.TriContourSet
+        """
+        had_data = self.has_data()
+
+        tri, args, kwargs = Triangulation.get_from_args_and_kwargs(
+                *args, **kwargs)
+        X = tri.x
+        Y = tri.y
+        if 'Z' in kwargs:
+            Z = kwargs.pop('Z')
+        else:
+            # We do this so Z doesn't get passed as an arg to Axes.tricontourf
+            Z, *args = args
+
+        jX, jY, jZ = art3d.rotate_axes(X, Y, Z, zdir)
+        tri = Triangulation(jX, jY, tri.triangles, tri.mask)
+
+        cset = super().tricontourf(tri, jZ, *args, **kwargs)
+        levels = self._add_contourf_set(cset, zdir, offset)
+
+        self._auto_scale_contourf(X, Y, Z, zdir, levels, had_data)
+        return cset
+
+    def add_collection3d(self, col, zs=0, zdir='z', autolim=True):
+        """
+        Add a 3D collection object to the plot.
+
+        2D collection types are converted to a 3D version by
+        modifying the object and adding z coordinate information,
+        *zs* and *zdir*.
+
+        Supported 2D collection types are:
+
+        - `.PolyCollection`
+        - `.LineCollection`
+        - `.PatchCollection` (currently not supporting *autolim*)
+
+        Parameters
+        ----------
+        col : `.Collection`
+            A 2D collection object.
+        zs : float or array-like, default: 0
+            The z-positions to be used for the 2D objects.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            The direction to use for the z-positions.
+        autolim : bool, default: True
+            Whether to update the data limits.
+        """
+        had_data = self.has_data()
+
+        zvals = np.atleast_1d(zs)
+        zsortval = (np.min(zvals) if zvals.size
+                    else 0)  # FIXME: arbitrary default
+
+        # FIXME: use issubclass() (although, then a 3D collection
+        #       object would also pass.)  Maybe have a collection3d
+        #       abstract class to test for and exclude?
+        if type(col) is mcoll.PolyCollection:
+            art3d.poly_collection_2d_to_3d(col, zs=zs, zdir=zdir)
+            col.set_sort_zpos(zsortval)
+        elif type(col) is mcoll.LineCollection:
+            art3d.line_collection_2d_to_3d(col, zs=zs, zdir=zdir)
+            col.set_sort_zpos(zsortval)
+        elif type(col) is mcoll.PatchCollection:
+            art3d.patch_collection_2d_to_3d(col, zs=zs, zdir=zdir)
+            col.set_sort_zpos(zsortval)
+
+        if autolim:
+            if isinstance(col, art3d.Line3DCollection):
+                self.auto_scale_xyz(*np.array(col._segments3d).transpose(),
+                                    had_data=had_data)
+            elif isinstance(col, art3d.Poly3DCollection):
+                self.auto_scale_xyz(*col._vec[:-1], had_data=had_data)
+            elif isinstance(col, art3d.Patch3DCollection):
+                pass
+                # FIXME: Implement auto-scaling function for Patch3DCollection
+                # Currently unable to do so due to issues with Patch3DCollection
+                # See https://github.com/matplotlib/matplotlib/issues/14298 for details
+
+        collection = super().add_collection(col)
+        return collection
+
+    @_preprocess_data(replace_names=["xs", "ys", "zs", "s",
+                                     "edgecolors", "c", "facecolor",
+                                     "facecolors", "color"])
+    def scatter(self, xs, ys, zs=0, zdir='z', s=20, c=None, depthshade=True,
+                *args, **kwargs):
+        """
+        Create a scatter plot.
+
+        Parameters
+        ----------
+        xs, ys : array-like
+            The data positions.
+        zs : float or array-like, default: 0
+            The z-positions. Either an array of the same length as *xs* and
+            *ys* or a single value to place all points in the same plane.
+        zdir : {'x', 'y', 'z', '-x', '-y', '-z'}, default: 'z'
+            The axis direction for the *zs*. This is useful when plotting 2D
+            data on a 3D Axes. The data must be passed as *xs*, *ys*. Setting
+            *zdir* to 'y' then plots the data to the x-z-plane.
+
+            See also :doc:`/gallery/mplot3d/2dcollections3d`.
+
+        s : float or array-like, default: 20
+            The marker size in points**2. Either an array of the same length
+            as *xs* and *ys* or a single value to make all markers the same
+            size.
+        c : :mpltype:`color`, sequence, or sequence of colors, optional
+            The marker color. Possible values:
+
+            - A single color format string.
+            - A sequence of colors of length n.
+            - A sequence of n numbers to be mapped to colors using *cmap* and
+              *norm*.
+            - A 2D array in which the rows are RGB or RGBA.
+
+            For more details see the *c* argument of `~.axes.Axes.scatter`.
+        depthshade : bool, default: True
+            Whether to shade the scatter markers to give the appearance of
+            depth. Each call to ``scatter()`` will perform its depthshading
+            independently.
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+        **kwargs
+            All other keyword arguments are passed on to `~.axes.Axes.scatter`.
+
+        Returns
+        -------
+        paths : `~matplotlib.collections.PathCollection`
+        """
+
+        had_data = self.has_data()
+        zs_orig = zs
+
+        xs, ys, zs = cbook._broadcast_with_masks(xs, ys, zs)
+        s = np.ma.ravel(s)  # This doesn't have to match x, y in size.
+
+        xs, ys, zs, s, c, color = cbook.delete_masked_points(
+            xs, ys, zs, s, c, kwargs.get('color', None)
+            )
+        if kwargs.get("color") is not None:
+            kwargs['color'] = color
+
+        # For xs and ys, 2D scatter() will do the copying.
+        if np.may_share_memory(zs_orig, zs):  # Avoid unnecessary copies.
+            zs = zs.copy()
+
+        patches = super().scatter(xs, ys, s=s, c=c, *args, **kwargs)
+        art3d.patch_collection_2d_to_3d(patches, zs=zs, zdir=zdir,
+                                        depthshade=depthshade)
+
+        if self._zmargin < 0.05 and xs.size > 0:
+            self.set_zmargin(0.05)
+
+        self.auto_scale_xyz(xs, ys, zs, had_data)
+
+        return patches
+
+    scatter3D = scatter
+
+    @_preprocess_data()
+    def bar(self, left, height, zs=0, zdir='z', *args, **kwargs):
+        """
+        Add 2D bar(s).
+
+        Parameters
+        ----------
+        left : 1D array-like
+            The x coordinates of the left sides of the bars.
+        height : 1D array-like
+            The height of the bars.
+        zs : float or 1D array-like, default: 0
+            Z coordinate of bars; if a single value is specified, it will be
+            used for all bars.
+        zdir : {'x', 'y', 'z'}, default: 'z'
+            When plotting 2D data, the direction to use as z ('x', 'y' or 'z').
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+        **kwargs
+            Other keyword arguments are forwarded to
+            `matplotlib.axes.Axes.bar`.
+
+        Returns
+        -------
+        mpl_toolkits.mplot3d.art3d.Patch3DCollection
+        """
+        had_data = self.has_data()
+
+        patches = super().bar(left, height, *args, **kwargs)
+
+        zs = np.broadcast_to(zs, len(left), subok=True)
+
+        verts = []
+        verts_zs = []
+        for p, z in zip(patches, zs):
+            vs = art3d._get_patch_verts(p)
+            verts += vs.tolist()
+            verts_zs += [z] * len(vs)
+            art3d.patch_2d_to_3d(p, z, zdir)
+            if 'alpha' in kwargs:
+                p.set_alpha(kwargs['alpha'])
+
+        if len(verts) > 0:
+            # the following has to be skipped if verts is empty
+            # NOTE: Bugs could still occur if len(verts) > 0,
+            #       but the "2nd dimension" is empty.
+            xs, ys = zip(*verts)
+        else:
+            xs, ys = [], []
+
+        xs, ys, verts_zs = art3d.juggle_axes(xs, ys, verts_zs, zdir)
+        self.auto_scale_xyz(xs, ys, verts_zs, had_data)
+
+        return patches
+
+    @_preprocess_data()
+    def bar3d(self, x, y, z, dx, dy, dz, color=None,
+              zsort='average', shade=True, lightsource=None, *args, **kwargs):
+        """
+        Generate a 3D barplot.
+
+        This method creates three-dimensional barplot where the width,
+        depth, height, and color of the bars can all be uniquely set.
+
+        Parameters
+        ----------
+        x, y, z : array-like
+            The coordinates of the anchor point of the bars.
+
+        dx, dy, dz : float or array-like
+            The width, depth, and height of the bars, respectively.
+
+        color : sequence of colors, optional
+            The color of the bars can be specified globally or
+            individually. This parameter can be:
+
+            - A single color, to color all bars the same color.
+            - An array of colors of length N bars, to color each bar
+              independently.
+            - An array of colors of length 6, to color the faces of the
+              bars similarly.
+            - An array of colors of length 6 * N bars, to color each face
+              independently.
+
+            When coloring the faces of the boxes specifically, this is
+            the order of the coloring:
+
+            1. -Z (bottom of box)
+            2. +Z (top of box)
+            3. -Y
+            4. +Y
+            5. -X
+            6. +X
+
+        zsort : {'average', 'min', 'max'}, default: 'average'
+            The z-axis sorting scheme passed onto `~.art3d.Poly3DCollection`
+
+        shade : bool, default: True
+            When true, this shades the dark sides of the bars (relative
+            to the plot's source of light).
+
+        lightsource : `~matplotlib.colors.LightSource`, optional
+            The lightsource to use when *shade* is True.
+
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+
+        **kwargs
+            Any additional keyword arguments are passed onto
+            `~.art3d.Poly3DCollection`.
+
+        Returns
+        -------
+        collection : `~.art3d.Poly3DCollection`
+            A collection of three-dimensional polygons representing the bars.
+        """
+
+        had_data = self.has_data()
+
+        x, y, z, dx, dy, dz = np.broadcast_arrays(
+            np.atleast_1d(x), y, z, dx, dy, dz)
+        minx = np.min(x)
+        maxx = np.max(x + dx)
+        miny = np.min(y)
+        maxy = np.max(y + dy)
+        minz = np.min(z)
+        maxz = np.max(z + dz)
+
+        # shape (6, 4, 3)
+        # All faces are oriented facing outwards - when viewed from the
+        # outside, their vertices are in a counterclockwise ordering.
+        cuboid = np.array([
+            # -z
+            (
+                (0, 0, 0),
+                (0, 1, 0),
+                (1, 1, 0),
+                (1, 0, 0),
+            ),
+            # +z
+            (
+                (0, 0, 1),
+                (1, 0, 1),
+                (1, 1, 1),
+                (0, 1, 1),
+            ),
+            # -y
+            (
+                (0, 0, 0),
+                (1, 0, 0),
+                (1, 0, 1),
+                (0, 0, 1),
+            ),
+            # +y
+            (
+                (0, 1, 0),
+                (0, 1, 1),
+                (1, 1, 1),
+                (1, 1, 0),
+            ),
+            # -x
+            (
+                (0, 0, 0),
+                (0, 0, 1),
+                (0, 1, 1),
+                (0, 1, 0),
+            ),
+            # +x
+            (
+                (1, 0, 0),
+                (1, 1, 0),
+                (1, 1, 1),
+                (1, 0, 1),
+            ),
+        ])
+
+        # indexed by [bar, face, vertex, coord]
+        polys = np.empty(x.shape + cuboid.shape)
+
+        # handle each coordinate separately
+        for i, p, dp in [(0, x, dx), (1, y, dy), (2, z, dz)]:
+            p = p[..., np.newaxis, np.newaxis]
+            dp = dp[..., np.newaxis, np.newaxis]
+            polys[..., i] = p + dp * cuboid[..., i]
+
+        # collapse the first two axes
+        polys = polys.reshape((-1,) + polys.shape[2:])
+
+        facecolors = []
+        if color is None:
+            color = [self._get_patches_for_fill.get_next_color()]
+
+        color = list(mcolors.to_rgba_array(color))
+
+        if len(color) == len(x):
+            # bar colors specified, need to expand to number of faces
+            for c in color:
+                facecolors.extend([c] * 6)
+        else:
+            # a single color specified, or face colors specified explicitly
+            facecolors = color
+            if len(facecolors) < len(x):
+                facecolors *= (6 * len(x))
+
+        col = art3d.Poly3DCollection(polys,
+                                     zsort=zsort,
+                                     facecolors=facecolors,
+                                     shade=shade,
+                                     lightsource=lightsource,
+                                     *args, **kwargs)
+        self.add_collection(col)
+
+        self.auto_scale_xyz((minx, maxx), (miny, maxy), (minz, maxz), had_data)
+
+        return col
+
+    def set_title(self, label, fontdict=None, loc='center', **kwargs):
+        # docstring inherited
+        ret = super().set_title(label, fontdict=fontdict, loc=loc, **kwargs)
+        (x, y) = self.title.get_position()
+        self.title.set_y(0.92 * y)
+        return ret
+
+    @_preprocess_data()
+    def quiver(self, X, Y, Z, U, V, W, *,
+               length=1, arrow_length_ratio=.3, pivot='tail', normalize=False,
+               **kwargs):
+        """
+        Plot a 3D field of arrows.
+
+        The arguments can be array-like or scalars, so long as they can be
+        broadcast together. The arguments can also be masked arrays. If an
+        element in any of argument is masked, then that corresponding quiver
+        element will not be plotted.
+
+        Parameters
+        ----------
+        X, Y, Z : array-like
+            The x, y and z coordinates of the arrow locations (default is
+            tail of arrow; see *pivot* kwarg).
+
+        U, V, W : array-like
+            The x, y and z components of the arrow vectors.
+
+        length : float, default: 1
+            The length of each quiver.
+
+        arrow_length_ratio : float, default: 0.3
+            The ratio of the arrow head with respect to the quiver.
+
+        pivot : {'tail', 'middle', 'tip'}, default: 'tail'
+            The part of the arrow that is at the grid point; the arrow
+            rotates about this point, hence the name *pivot*.
+
+        normalize : bool, default: False
+            Whether all arrows are normalized to have the same length, or keep
+            the lengths defined by *u*, *v*, and *w*.
+
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+
+        **kwargs
+            Any additional keyword arguments are delegated to
+            :class:`.Line3DCollection`
+        """
+
+        def calc_arrows(UVW):
+            # get unit direction vector perpendicular to (u, v, w)
+            x = UVW[:, 0]
+            y = UVW[:, 1]
+            norm = np.linalg.norm(UVW[:, :2], axis=1)
+            x_p = np.divide(y, norm, where=norm != 0, out=np.zeros_like(x))
+            y_p = np.divide(-x,  norm, where=norm != 0, out=np.ones_like(x))
+            # compute the two arrowhead direction unit vectors
+            rangle = math.radians(15)
+            c = math.cos(rangle)
+            s = math.sin(rangle)
+            # construct the rotation matrices of shape (3, 3, n)
+            r13 = y_p * s
+            r32 = x_p * s
+            r12 = x_p * y_p * (1 - c)
+            Rpos = np.array(
+                [[c + (x_p ** 2) * (1 - c), r12, r13],
+                 [r12, c + (y_p ** 2) * (1 - c), -r32],
+                 [-r13, r32, np.full_like(x_p, c)]])
+            # opposite rotation negates all the sin terms
+            Rneg = Rpos.copy()
+            Rneg[[0, 1, 2, 2], [2, 2, 0, 1]] *= -1
+            # Batch n (3, 3) x (3) matrix multiplications ((3, 3, n) x (n, 3)).
+            Rpos_vecs = np.einsum("ij...,...j->...i", Rpos, UVW)
+            Rneg_vecs = np.einsum("ij...,...j->...i", Rneg, UVW)
+            # Stack into (n, 2, 3) result.
+            return np.stack([Rpos_vecs, Rneg_vecs], axis=1)
+
+        had_data = self.has_data()
+
+        input_args = cbook._broadcast_with_masks(X, Y, Z, U, V, W,
+                                                 compress=True)
+
+        if any(len(v) == 0 for v in input_args):
+            # No quivers, so just make an empty collection and return early
+            linec = art3d.Line3DCollection([], **kwargs)
+            self.add_collection(linec)
+            return linec
+
+        shaft_dt = np.array([0., length], dtype=float)
+        arrow_dt = shaft_dt * arrow_length_ratio
+
+        _api.check_in_list(['tail', 'middle', 'tip'], pivot=pivot)
+        if pivot == 'tail':
+            shaft_dt -= length
+        elif pivot == 'middle':
+            shaft_dt -= length / 2
+
+        XYZ = np.column_stack(input_args[:3])
+        UVW = np.column_stack(input_args[3:]).astype(float)
+
+        # Normalize rows of UVW
+        if normalize:
+            norm = np.linalg.norm(UVW, axis=1)
+            norm[norm == 0] = 1
+            UVW = UVW / norm.reshape((-1, 1))
+
+        if len(XYZ) > 0:
+            # compute the shaft lines all at once with an outer product
+            shafts = (XYZ - np.multiply.outer(shaft_dt, UVW)).swapaxes(0, 1)
+            # compute head direction vectors, n heads x 2 sides x 3 dimensions
+            head_dirs = calc_arrows(UVW)
+            # compute all head lines at once, starting from the shaft ends
+            heads = shafts[:, :1] - np.multiply.outer(arrow_dt, head_dirs)
+            # stack left and right head lines together
+            heads = heads.reshape((len(arrow_dt), -1, 3))
+            # transpose to get a list of lines
+            heads = heads.swapaxes(0, 1)
+
+            lines = [*shafts, *heads[::2], *heads[1::2]]
+        else:
+            lines = []
+
+        linec = art3d.Line3DCollection(lines, **kwargs)
+        self.add_collection(linec)
+
+        self.auto_scale_xyz(XYZ[:, 0], XYZ[:, 1], XYZ[:, 2], had_data)
+
+        return linec
+
+    quiver3D = quiver
+
+    def voxels(self, *args, facecolors=None, edgecolors=None, shade=True,
+               lightsource=None, **kwargs):
+        """
+        ax.voxels([x, y, z,] /, filled, facecolors=None, edgecolors=None, \
+**kwargs)
+
+        Plot a set of filled voxels
+
+        All voxels are plotted as 1x1x1 cubes on the axis, with
+        ``filled[0, 0, 0]`` placed with its lower corner at the origin.
+        Occluded faces are not plotted.
+
+        Parameters
+        ----------
+        filled : 3D np.array of bool
+            A 3D array of values, with truthy values indicating which voxels
+            to fill
+
+        x, y, z : 3D np.array, optional
+            The coordinates of the corners of the voxels. This should broadcast
+            to a shape one larger in every dimension than the shape of
+            *filled*.  These can be used to plot non-cubic voxels.
+
+            If not specified, defaults to increasing integers along each axis,
+            like those returned by :func:`~numpy.indices`.
+            As indicated by the ``/`` in the function signature, these
+            arguments can only be passed positionally.
+
+        facecolors, edgecolors : array-like, optional
+            The color to draw the faces and edges of the voxels. Can only be
+            passed as keyword arguments.
+            These parameters can be:
+
+            - A single color value, to color all voxels the same color. This
+              can be either a string, or a 1D RGB/RGBA array
+            - ``None``, the default, to use a single color for the faces, and
+              the style default for the edges.
+            - A 3D `~numpy.ndarray` of color names, with each item the color
+              for the corresponding voxel. The size must match the voxels.
+            - A 4D `~numpy.ndarray` of RGB/RGBA data, with the components
+              along the last axis.
+
+        shade : bool, default: True
+            Whether to shade the facecolors.
+
+        lightsource : `~matplotlib.colors.LightSource`, optional
+            The lightsource to use when *shade* is True.
+
+        **kwargs
+            Additional keyword arguments to pass onto
+            `~mpl_toolkits.mplot3d.art3d.Poly3DCollection`.
+
+        Returns
+        -------
+        faces : dict
+            A dictionary indexed by coordinate, where ``faces[i, j, k]`` is a
+            `.Poly3DCollection` of the faces drawn for the voxel
+            ``filled[i, j, k]``. If no faces were drawn for a given voxel,
+            either because it was not asked to be drawn, or it is fully
+            occluded, then ``(i, j, k) not in faces``.
+
+        Examples
+        --------
+        .. plot:: gallery/mplot3d/voxels.py
+        .. plot:: gallery/mplot3d/voxels_rgb.py
+        .. plot:: gallery/mplot3d/voxels_torus.py
+        .. plot:: gallery/mplot3d/voxels_numpy_logo.py
+        """
+
+        # work out which signature we should be using, and use it to parse
+        # the arguments. Name must be voxels for the correct error message
+        if len(args) >= 3:
+            # underscores indicate position only
+            def voxels(__x, __y, __z, filled, **kwargs):
+                return (__x, __y, __z), filled, kwargs
+        else:
+            def voxels(filled, **kwargs):
+                return None, filled, kwargs
+
+        xyz, filled, kwargs = voxels(*args, **kwargs)
+
+        # check dimensions
+        if filled.ndim != 3:
+            raise ValueError("Argument filled must be 3-dimensional")
+        size = np.array(filled.shape, dtype=np.intp)
+
+        # check xyz coordinates, which are one larger than the filled shape
+        coord_shape = tuple(size + 1)
+        if xyz is None:
+            x, y, z = np.indices(coord_shape)
+        else:
+            x, y, z = (np.broadcast_to(c, coord_shape) for c in xyz)
+
+        def _broadcast_color_arg(color, name):
+            if np.ndim(color) in (0, 1):
+                # single color, like "red" or [1, 0, 0]
+                return np.broadcast_to(color, filled.shape + np.shape(color))
+            elif np.ndim(color) in (3, 4):
+                # 3D array of strings, or 4D array with last axis rgb
+                if np.shape(color)[:3] != filled.shape:
+                    raise ValueError(
+                        f"When multidimensional, {name} must match the shape "
+                        "of filled")
+                return color
+            else:
+                raise ValueError(f"Invalid {name} argument")
+
+        # broadcast and default on facecolors
+        if facecolors is None:
+            facecolors = self._get_patches_for_fill.get_next_color()
+        facecolors = _broadcast_color_arg(facecolors, 'facecolors')
+
+        # broadcast but no default on edgecolors
+        edgecolors = _broadcast_color_arg(edgecolors, 'edgecolors')
+
+        # scale to the full array, even if the data is only in the center
+        self.auto_scale_xyz(x, y, z)
+
+        # points lying on corners of a square
+        square = np.array([
+            [0, 0, 0],
+            [1, 0, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+        ], dtype=np.intp)
+
+        voxel_faces = defaultdict(list)
+
+        def permutation_matrices(n):
+            """Generate cyclic permutation matrices."""
+            mat = np.eye(n, dtype=np.intp)
+            for i in range(n):
+                yield mat
+                mat = np.roll(mat, 1, axis=0)
+
+        # iterate over each of the YZ, ZX, and XY orientations, finding faces
+        # to render
+        for permute in permutation_matrices(3):
+            # find the set of ranges to iterate over
+            pc, qc, rc = permute.T.dot(size)
+            pinds = np.arange(pc)
+            qinds = np.arange(qc)
+            rinds = np.arange(rc)
+
+            square_rot_pos = square.dot(permute.T)
+            square_rot_neg = square_rot_pos[::-1]
+
+            # iterate within the current plane
+            for p in pinds:
+                for q in qinds:
+                    # iterate perpendicularly to the current plane, handling
+                    # boundaries. We only draw faces between a voxel and an
+                    # empty space, to avoid drawing internal faces.
+
+                    # draw lower faces
+                    p0 = permute.dot([p, q, 0])
+                    i0 = tuple(p0)
+                    if filled[i0]:
+                        voxel_faces[i0].append(p0 + square_rot_neg)
+
+                    # draw middle faces
+                    for r1, r2 in zip(rinds[:-1], rinds[1:]):
+                        p1 = permute.dot([p, q, r1])
+                        p2 = permute.dot([p, q, r2])
+
+                        i1 = tuple(p1)
+                        i2 = tuple(p2)
+
+                        if filled[i1] and not filled[i2]:
+                            voxel_faces[i1].append(p2 + square_rot_pos)
+                        elif not filled[i1] and filled[i2]:
+                            voxel_faces[i2].append(p2 + square_rot_neg)
+
+                    # draw upper faces
+                    pk = permute.dot([p, q, rc-1])
+                    pk2 = permute.dot([p, q, rc])
+                    ik = tuple(pk)
+                    if filled[ik]:
+                        voxel_faces[ik].append(pk2 + square_rot_pos)
+
+        # iterate over the faces, and generate a Poly3DCollection for each
+        # voxel
+        polygons = {}
+        for coord, faces_inds in voxel_faces.items():
+            # convert indices into 3D positions
+            if xyz is None:
+                faces = faces_inds
+            else:
+                faces = []
+                for face_inds in faces_inds:
+                    ind = face_inds[:, 0], face_inds[:, 1], face_inds[:, 2]
+                    face = np.empty(face_inds.shape)
+                    face[:, 0] = x[ind]
+                    face[:, 1] = y[ind]
+                    face[:, 2] = z[ind]
+                    faces.append(face)
+
+            # shade the faces
+            facecolor = facecolors[coord]
+            edgecolor = edgecolors[coord]
+
+            poly = art3d.Poly3DCollection(
+                faces, facecolors=facecolor, edgecolors=edgecolor,
+                shade=shade, lightsource=lightsource, **kwargs)
+            self.add_collection3d(poly)
+            polygons[coord] = poly
+
+        return polygons
+
+    @_preprocess_data(replace_names=["x", "y", "z", "xerr", "yerr", "zerr"])
+    def errorbar(self, x, y, z, zerr=None, yerr=None, xerr=None, fmt='',
+                 barsabove=False, errorevery=1, ecolor=None, elinewidth=None,
+                 capsize=None, capthick=None, xlolims=False, xuplims=False,
+                 ylolims=False, yuplims=False, zlolims=False, zuplims=False,
+                 **kwargs):
+        """
+        Plot lines and/or markers with errorbars around them.
+
+        *x*/*y*/*z* define the data locations, and *xerr*/*yerr*/*zerr* define
+        the errorbar sizes. By default, this draws the data markers/lines as
+        well the errorbars. Use fmt='none' to draw errorbars only.
+
+        Parameters
+        ----------
+        x, y, z : float or array-like
+            The data positions.
+
+        xerr, yerr, zerr : float or array-like, shape (N,) or (2, N), optional
+            The errorbar sizes:
+
+            - scalar: Symmetric +/- values for all data points.
+            - shape(N,): Symmetric +/-values for each data point.
+            - shape(2, N): Separate - and + values for each bar. First row
+              contains the lower errors, the second row contains the upper
+              errors.
+            - *None*: No errorbar.
+
+            Note that all error arrays should have *positive* values.
+
+        fmt : str, default: ''
+            The format for the data points / data lines. See `.plot` for
+            details.
+
+            Use 'none' (case-insensitive) to plot errorbars without any data
+            markers.
+
+        ecolor : :mpltype:`color`, default: None
+            The color of the errorbar lines.  If None, use the color of the
+            line connecting the markers.
+
+        elinewidth : float, default: None
+            The linewidth of the errorbar lines. If None, the linewidth of
+            the current style is used.
+
+        capsize : float, default: :rc:`errorbar.capsize`
+            The length of the error bar caps in points.
+
+        capthick : float, default: None
+            An alias to the keyword argument *markeredgewidth* (a.k.a. *mew*).
+            This setting is a more sensible name for the property that
+            controls the thickness of the error bar cap in points. For
+            backwards compatibility, if *mew* or *markeredgewidth* are given,
+            then they will over-ride *capthick*. This may change in future
+            releases.
+
+        barsabove : bool, default: False
+            If True, will plot the errorbars above the plot
+            symbols. Default is below.
+
+        xlolims, ylolims, zlolims : bool, default: False
+            These arguments can be used to indicate that a value gives only
+            lower limits. In that case a caret symbol is used to indicate
+            this. *lims*-arguments may be scalars, or array-likes of the same
+            length as the errors. To use limits with inverted axes,
+            `~.set_xlim`, `~.set_ylim`, or `~.set_zlim` must be
+            called before `errorbar`. Note the tricky parameter names: setting
+            e.g. *ylolims* to True means that the y-value is a *lower* limit of
+            the True value, so, only an *upward*-pointing arrow will be drawn!
+
+        xuplims, yuplims, zuplims : bool, default: False
+            Same as above, but for controlling the upper limits.
+
+        errorevery : int or (int, int), default: 1
+            draws error bars on a subset of the data. *errorevery* =N draws
+            error bars on the points (x[::N], y[::N], z[::N]).
+            *errorevery* =(start, N) draws error bars on the points
+            (x[start::N], y[start::N], z[start::N]). e.g. *errorevery* =(6, 3)
+            adds error bars to the data at (x[6], x[9], x[12], x[15], ...).
+            Used to avoid overlapping error bars when two series share x-axis
+            values.
+
+        Returns
+        -------
+        errlines : list
+            List of `~mpl_toolkits.mplot3d.art3d.Line3DCollection` instances
+            each containing an errorbar line.
+        caplines : list
+            List of `~mpl_toolkits.mplot3d.art3d.Line3D` instances each
+            containing a capline object.
+        limmarks : list
+            List of `~mpl_toolkits.mplot3d.art3d.Line3D` instances each
+            containing a marker with an upper or lower limit.
+
+        Other Parameters
+        ----------------
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+
+        **kwargs
+            All other keyword arguments for styling errorbar lines are passed
+            `~mpl_toolkits.mplot3d.art3d.Line3DCollection`.
+
+        Examples
+        --------
+        .. plot:: gallery/mplot3d/errorbar3d.py
+        """
+        had_data = self.has_data()
+
+        kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
+        # Drop anything that comes in as None to use the default instead.
+        kwargs = {k: v for k, v in kwargs.items() if v is not None}
+        kwargs.setdefault('zorder', 2)
+
+        self._process_unit_info([("x", x), ("y", y), ("z", z)], kwargs,
+                                convert=False)
+
+        # make sure all the args are iterable; use lists not arrays to
+        # preserve units
+        x = x if np.iterable(x) else [x]
+        y = y if np.iterable(y) else [y]
+        z = z if np.iterable(z) else [z]
+
+        if not len(x) == len(y) == len(z):
+            raise ValueError("'x', 'y', and 'z' must have the same size")
+
+        everymask = self._errorevery_to_mask(x, errorevery)
+
+        label = kwargs.pop("label", None)
+        kwargs['label'] = '_nolegend_'
+
+        # Create the main line and determine overall kwargs for child artists.
+        # We avoid calling self.plot() directly, or self._get_lines(), because
+        # that would call self._process_unit_info again, and do other indirect
+        # data processing.
+        (data_line, base_style), = self._get_lines._plot_args(
+            self, (x, y) if fmt == '' else (x, y, fmt), kwargs, return_kwargs=True)
+        art3d.line_2d_to_3d(data_line, zs=z)
+
+        # Do this after creating `data_line` to avoid modifying `base_style`.
+        if barsabove:
+            data_line.set_zorder(kwargs['zorder'] - .1)
+        else:
+            data_line.set_zorder(kwargs['zorder'] + .1)
+
+        # Add line to plot, or throw it away and use it to determine kwargs.
+        if fmt.lower() != 'none':
+            self.add_line(data_line)
+        else:
+            data_line = None
+            # Remove alpha=0 color that _process_plot_format returns.
+            base_style.pop('color')
+
+        if 'color' not in base_style:
+            base_style['color'] = 'C0'
+        if ecolor is None:
+            ecolor = base_style['color']
+
+        # Eject any line-specific information from format string, as it's not
+        # needed for bars or caps.
+        for key in ['marker', 'markersize', 'markerfacecolor',
+                    'markeredgewidth', 'markeredgecolor', 'markevery',
+                    'linestyle', 'fillstyle', 'drawstyle', 'dash_capstyle',
+                    'dash_joinstyle', 'solid_capstyle', 'solid_joinstyle']:
+            base_style.pop(key, None)
+
+        # Make the style dict for the line collections (the bars).
+        eb_lines_style = {**base_style, 'color': ecolor}
+
+        if elinewidth:
+            eb_lines_style['linewidth'] = elinewidth
+        elif 'linewidth' in kwargs:
+            eb_lines_style['linewidth'] = kwargs['linewidth']
+
+        for key in ('transform', 'alpha', 'zorder', 'rasterized'):
+            if key in kwargs:
+                eb_lines_style[key] = kwargs[key]
+
+        # Make the style dict for caps (the "hats").
+        eb_cap_style = {**base_style, 'linestyle': 'None'}
+        if capsize is None:
+            capsize = mpl.rcParams["errorbar.capsize"]
+        if capsize > 0:
+            eb_cap_style['markersize'] = 2. * capsize
+        if capthick is not None:
+            eb_cap_style['markeredgewidth'] = capthick
+        eb_cap_style['color'] = ecolor
+
+        def _apply_mask(arrays, mask):
+            # Return, for each array in *arrays*, the elements for which *mask*
+            # is True, without using fancy indexing.
+            return [[*itertools.compress(array, mask)] for array in arrays]
+
+        def _extract_errs(err, data, lomask, himask):
+            # For separate +/- error values we need to unpack err
+            if len(err.shape) == 2:
+                low_err, high_err = err
+            else:
+                low_err, high_err = err, err
+
+            lows = np.where(lomask | ~everymask, data, data - low_err)
+            highs = np.where(himask | ~everymask, data, data + high_err)
+
+            return lows, highs
+
+        # collect drawn items while looping over the three coordinates
+        errlines, caplines, limmarks = [], [], []
+
+        # list of endpoint coordinates, used for auto-scaling
+        coorderrs = []
+
+        # define the markers used for errorbar caps and limits below
+        # the dictionary key is mapped by the `i_xyz` helper dictionary
+        capmarker = {0: '|', 1: '|', 2: '_'}
+        i_xyz = {'x': 0, 'y': 1, 'z': 2}
+
+        # Calculate marker size from points to quiver length. Because these are
+        # not markers, and 3D Axes do not use the normal transform stack, this
+        # is a bit involved. Since the quiver arrows will change size as the
+        # scene is rotated, they are given a standard size based on viewing
+        # them directly in planar form.
+        quiversize = eb_cap_style.get('markersize',
+                                      mpl.rcParams['lines.markersize']) ** 2
+        quiversize *= self.figure.dpi / 72
+        quiversize = self.transAxes.inverted().transform([
+            (0, 0), (quiversize, quiversize)])
+        quiversize = np.mean(np.diff(quiversize, axis=0))
+        # quiversize is now in Axes coordinates, and to convert back to data
+        # coordinates, we need to run it through the inverse 3D transform. For
+        # consistency, this uses a fixed elevation, azimuth, and roll.
+        with cbook._setattr_cm(self, elev=0, azim=0, roll=0):
+            invM = np.linalg.inv(self.get_proj())
+        # elev=azim=roll=0 produces the Y-Z plane, so quiversize in 2D 'x' is
+        # 'y' in 3D, hence the 1 index.
+        quiversize = np.dot(invM, [quiversize, 0, 0, 0])[1]
+        # Quivers use a fixed 15-degree arrow head, so scale up the length so
+        # that the size corresponds to the base. In other words, this constant
+        # corresponds to the equation tan(15) = (base / 2) / (arrow length).
+        quiversize *= 1.8660254037844388
+        eb_quiver_style = {**eb_cap_style,
+                           'length': quiversize, 'arrow_length_ratio': 1}
+        eb_quiver_style.pop('markersize', None)
+
+        # loop over x-, y-, and z-direction and draw relevant elements
+        for zdir, data, err, lolims, uplims in zip(
+                ['x', 'y', 'z'], [x, y, z], [xerr, yerr, zerr],
+                [xlolims, ylolims, zlolims], [xuplims, yuplims, zuplims]):
+
+            dir_vector = art3d.get_dir_vector(zdir)
+            i_zdir = i_xyz[zdir]
+
+            if err is None:
+                continue
+
+            if not np.iterable(err):
+                err = [err] * len(data)
+
+            err = np.atleast_1d(err)
+
+            # arrays fine here, they are booleans and hence not units
+            lolims = np.broadcast_to(lolims, len(data)).astype(bool)
+            uplims = np.broadcast_to(uplims, len(data)).astype(bool)
+
+            # a nested list structure that expands to (xl,xh),(yl,yh),(zl,zh),
+            # where x/y/z and l/h correspond to dimensions and low/high
+            # positions of errorbars in a dimension we're looping over
+            coorderr = [
+                _extract_errs(err * dir_vector[i], coord, lolims, uplims)
+                for i, coord in enumerate([x, y, z])]
+            (xl, xh), (yl, yh), (zl, zh) = coorderr
+
+            # draws capmarkers - flat caps orthogonal to the error bars
+            nolims = ~(lolims | uplims)
+            if nolims.any() and capsize > 0:
+                lo_caps_xyz = _apply_mask([xl, yl, zl], nolims & everymask)
+                hi_caps_xyz = _apply_mask([xh, yh, zh], nolims & everymask)
+
+                # setting '_' for z-caps and '|' for x- and y-caps;
+                # these markers will rotate as the viewing angle changes
+                cap_lo = art3d.Line3D(*lo_caps_xyz, ls='',
+                                      marker=capmarker[i_zdir],
+                                      **eb_cap_style)
+                cap_hi = art3d.Line3D(*hi_caps_xyz, ls='',
+                                      marker=capmarker[i_zdir],
+                                      **eb_cap_style)
+                self.add_line(cap_lo)
+                self.add_line(cap_hi)
+                caplines.append(cap_lo)
+                caplines.append(cap_hi)
+
+            if lolims.any():
+                xh0, yh0, zh0 = _apply_mask([xh, yh, zh], lolims & everymask)
+                self.quiver(xh0, yh0, zh0, *dir_vector, **eb_quiver_style)
+            if uplims.any():
+                xl0, yl0, zl0 = _apply_mask([xl, yl, zl], uplims & everymask)
+                self.quiver(xl0, yl0, zl0, *-dir_vector, **eb_quiver_style)
+
+            errline = art3d.Line3DCollection(np.array(coorderr).T,
+                                             **eb_lines_style)
+            self.add_collection(errline)
+            errlines.append(errline)
+            coorderrs.append(coorderr)
+
+        coorderrs = np.array(coorderrs)
+
+        def _digout_minmax(err_arr, coord_label):
+            return (np.nanmin(err_arr[:, i_xyz[coord_label], :, :]),
+                    np.nanmax(err_arr[:, i_xyz[coord_label], :, :]))
+
+        minx, maxx = _digout_minmax(coorderrs, 'x')
+        miny, maxy = _digout_minmax(coorderrs, 'y')
+        minz, maxz = _digout_minmax(coorderrs, 'z')
+        self.auto_scale_xyz((minx, maxx), (miny, maxy), (minz, maxz), had_data)
+
+        # Adapting errorbar containers for 3d case, assuming z-axis points "up"
+        errorbar_container = mcontainer.ErrorbarContainer(
+            (data_line, tuple(caplines), tuple(errlines)),
+            has_xerr=(xerr is not None or yerr is not None),
+            has_yerr=(zerr is not None),
+            label=label)
+        self.containers.append(errorbar_container)
+
+        return errlines, caplines, limmarks
+
+    @_api.make_keyword_only("3.8", "call_axes_locator")
+    def get_tightbbox(self, renderer=None, call_axes_locator=True,
+                      bbox_extra_artists=None, *, for_layout_only=False):
+        ret = super().get_tightbbox(renderer,
+                                    call_axes_locator=call_axes_locator,
+                                    bbox_extra_artists=bbox_extra_artists,
+                                    for_layout_only=for_layout_only)
+        batch = [ret]
+        if self._axis3don:
+            for axis in self._axis_map.values():
+                if axis.get_visible():
+                    axis_bb = martist._get_tightbbox_for_layout_only(
+                        axis, renderer)
+                    if axis_bb:
+                        batch.append(axis_bb)
+        return mtransforms.Bbox.union(batch)
+
+    @_preprocess_data()
+    def stem(self, x, y, z, *, linefmt='C0-', markerfmt='C0o', basefmt='C3-',
+             bottom=0, label=None, orientation='z'):
+        """
+        Create a 3D stem plot.
+
+        A stem plot draws lines perpendicular to a baseline, and places markers
+        at the heads. By default, the baseline is defined by *x* and *y*, and
+        stems are drawn vertically from *bottom* to *z*.
+
+        Parameters
+        ----------
+        x, y, z : array-like
+            The positions of the heads of the stems. The stems are drawn along
+            the *orientation*-direction from the baseline at *bottom* (in the
+            *orientation*-coordinate) to the heads. By default, the *x* and *y*
+            positions are used for the baseline and *z* for the head position,
+            but this can be changed by *orientation*.
+
+        linefmt : str, default: 'C0-'
+            A string defining the properties of the vertical lines. Usually,
+            this will be a color or a color and a linestyle:
+
+            =========  =============
+            Character  Line Style
+            =========  =============
+            ``'-'``    solid line
+            ``'--'``   dashed line
+            ``'-.'``   dash-dot line
+            ``':'``    dotted line
+            =========  =============
+
+            Note: While it is technically possible to specify valid formats
+            other than color or color and linestyle (e.g. 'rx' or '-.'), this
+            is beyond the intention of the method and will most likely not
+            result in a reasonable plot.
+
+        markerfmt : str, default: 'C0o'
+            A string defining the properties of the markers at the stem heads.
+
+        basefmt : str, default: 'C3-'
+            A format string defining the properties of the baseline.
+
+        bottom : float, default: 0
+            The position of the baseline, in *orientation*-coordinates.
+
+        label : str, optional
+            The label to use for the stems in legends.
+
+        orientation : {'x', 'y', 'z'}, default: 'z'
+            The direction along which stems are drawn.
+
+        data : indexable object, optional
+            DATA_PARAMETER_PLACEHOLDER
+
+        Returns
+        -------
+        `.StemContainer`
+            The container may be treated like a tuple
+            (*markerline*, *stemlines*, *baseline*)
+
+        Examples
+        --------
+        .. plot:: gallery/mplot3d/stem3d_demo.py
+        """
+
+        from matplotlib.container import StemContainer
+
+        had_data = self.has_data()
+
+        _api.check_in_list(['x', 'y', 'z'], orientation=orientation)
+
+        xlim = (np.min(x), np.max(x))
+        ylim = (np.min(y), np.max(y))
+        zlim = (np.min(z), np.max(z))
+
+        # Determine the appropriate plane for the baseline and the direction of
+        # stemlines based on the value of orientation.
+        if orientation == 'x':
+            basex, basexlim = y, ylim
+            basey, baseylim = z, zlim
+            lines = [[(bottom, thisy, thisz), (thisx, thisy, thisz)]
+                     for thisx, thisy, thisz in zip(x, y, z)]
+        elif orientation == 'y':
+            basex, basexlim = x, xlim
+            basey, baseylim = z, zlim
+            lines = [[(thisx, bottom, thisz), (thisx, thisy, thisz)]
+                     for thisx, thisy, thisz in zip(x, y, z)]
+        else:
+            basex, basexlim = x, xlim
+            basey, baseylim = y, ylim
+            lines = [[(thisx, thisy, bottom), (thisx, thisy, thisz)]
+                     for thisx, thisy, thisz in zip(x, y, z)]
+
+        # Determine style for stem lines.
+        linestyle, linemarker, linecolor = _process_plot_format(linefmt)
+        if linestyle is None:
+            linestyle = mpl.rcParams['lines.linestyle']
+
+        # Plot everything in required order.
+        baseline, = self.plot(basex, basey, basefmt, zs=bottom,
+                              zdir=orientation, label='_nolegend_')
+        stemlines = art3d.Line3DCollection(
+            lines, linestyles=linestyle, colors=linecolor, label='_nolegend_')
+        self.add_collection(stemlines)
+        markerline, = self.plot(x, y, z, markerfmt, label='_nolegend_')
+
+        stem_container = StemContainer((markerline, stemlines, baseline),
+                                       label=label)
+        self.add_container(stem_container)
+
+        jx, jy, jz = art3d.juggle_axes(basexlim, baseylim, [bottom, bottom],
+                                       orientation)
+        self.auto_scale_xyz([*jx, *xlim], [*jy, *ylim], [*jz, *zlim], had_data)
+
+        return stem_container
+
+    stem3D = stem
+
+
+def get_test_data(delta=0.05):
+    """Return a tuple X, Y, Z with a test data set."""
+    x = y = np.arange(-3.0, 3.0, delta)
+    X, Y = np.meshgrid(x, y)
+
+    Z1 = np.exp(-(X**2 + Y**2) / 2) / (2 * np.pi)
+    Z2 = (np.exp(-(((X - 1) / 1.5)**2 + ((Y - 1) / 0.5)**2) / 2) /
+          (2 * np.pi * 0.5 * 1.5))
+    Z = Z2 - Z1
+
+    X = X * 10
+    Y = Y * 10
+    Z = Z * 500
+    return X, Y, Z
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axis3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axis3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..79b78657bdb909f7126c90ddbf58721b5af58b09
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axis3d.py
@@ -0,0 +1,760 @@
+# axis3d.py, original mplot3d version by John Porter
+# Created: 23 Sep 2005
+# Parts rewritten by Reinier Heeres <reinier@heeres.eu>
+
+import inspect
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib import (
+    _api, artist, lines as mlines, axis as maxis, patches as mpatches,
+    transforms as mtransforms, colors as mcolors)
+from . import art3d, proj3d
+
+
+def _move_from_center(coord, centers, deltas, axmask=(True, True, True)):
+    """
+    For each coordinate where *axmask* is True, move *coord* away from
+    *centers* by *deltas*.
+    """
+    coord = np.asarray(coord)
+    return coord + axmask * np.copysign(1, coord - centers) * deltas
+
+
+def _tick_update_position(tick, tickxs, tickys, labelpos):
+    """Update tick line and label position and style."""
+
+    tick.label1.set_position(labelpos)
+    tick.label2.set_position(labelpos)
+    tick.tick1line.set_visible(True)
+    tick.tick2line.set_visible(False)
+    tick.tick1line.set_linestyle('-')
+    tick.tick1line.set_marker('')
+    tick.tick1line.set_data(tickxs, tickys)
+    tick.gridline.set_data([0], [0])
+
+
+class Axis(maxis.XAxis):
+    """An Axis class for the 3D plots."""
+    # These points from the unit cube make up the x, y and z-planes
+    _PLANES = (
+        (0, 3, 7, 4), (1, 2, 6, 5),  # yz planes
+        (0, 1, 5, 4), (3, 2, 6, 7),  # xz planes
+        (0, 1, 2, 3), (4, 5, 6, 7),  # xy planes
+    )
+
+    # Some properties for the axes
+    _AXINFO = {
+        'x': {'i': 0, 'tickdir': 1, 'juggled': (1, 0, 2)},
+        'y': {'i': 1, 'tickdir': 0, 'juggled': (0, 1, 2)},
+        'z': {'i': 2, 'tickdir': 0, 'juggled': (0, 2, 1)},
+    }
+
+    def _old_init(self, adir, v_intervalx, d_intervalx, axes, *args,
+                  rotate_label=None, **kwargs):
+        return locals()
+
+    def _new_init(self, axes, *, rotate_label=None, **kwargs):
+        return locals()
+
+    def __init__(self, *args, **kwargs):
+        params = _api.select_matching_signature(
+            [self._old_init, self._new_init], *args, **kwargs)
+        if "adir" in params:
+            _api.warn_deprecated(
+                "3.6", message=f"The signature of 3D Axis constructors has "
+                f"changed in %(since)s; the new signature is "
+                f"{inspect.signature(type(self).__init__)}", pending=True)
+            if params["adir"] != self.axis_name:
+                raise ValueError(f"Cannot instantiate {type(self).__name__} "
+                                 f"with adir={params['adir']!r}")
+        axes = params["axes"]
+        rotate_label = params["rotate_label"]
+        args = params.get("args", ())
+        kwargs = params["kwargs"]
+
+        name = self.axis_name
+
+        self._label_position = 'default'
+        self._tick_position = 'default'
+
+        # This is a temporary member variable.
+        # Do not depend on this existing in future releases!
+        self._axinfo = self._AXINFO[name].copy()
+        # Common parts
+        self._axinfo.update({
+            'label': {'va': 'center', 'ha': 'center',
+                      'rotation_mode': 'anchor'},
+            'color': mpl.rcParams[f'axes3d.{name}axis.panecolor'],
+            'tick': {
+                'inward_factor': 0.2,
+                'outward_factor': 0.1,
+            },
+        })
+
+        if mpl.rcParams['_internal.classic_mode']:
+            self._axinfo.update({
+                'axisline': {'linewidth': 0.75, 'color': (0, 0, 0, 1)},
+                'grid': {
+                    'color': (0.9, 0.9, 0.9, 1),
+                    'linewidth': 1.0,
+                    'linestyle': '-',
+                },
+            })
+            self._axinfo['tick'].update({
+                'linewidth': {
+                    True: mpl.rcParams['lines.linewidth'],  # major
+                    False: mpl.rcParams['lines.linewidth'],  # minor
+                }
+            })
+        else:
+            self._axinfo.update({
+                'axisline': {
+                    'linewidth': mpl.rcParams['axes.linewidth'],
+                    'color': mpl.rcParams['axes.edgecolor'],
+                },
+                'grid': {
+                    'color': mpl.rcParams['grid.color'],
+                    'linewidth': mpl.rcParams['grid.linewidth'],
+                    'linestyle': mpl.rcParams['grid.linestyle'],
+                },
+            })
+            self._axinfo['tick'].update({
+                'linewidth': {
+                    True: (  # major
+                        mpl.rcParams['xtick.major.width'] if name in 'xz'
+                        else mpl.rcParams['ytick.major.width']),
+                    False: (  # minor
+                        mpl.rcParams['xtick.minor.width'] if name in 'xz'
+                        else mpl.rcParams['ytick.minor.width']),
+                }
+            })
+
+        super().__init__(axes, *args, **kwargs)
+
+        # data and viewing intervals for this direction
+        if "d_intervalx" in params:
+            self.set_data_interval(*params["d_intervalx"])
+        if "v_intervalx" in params:
+            self.set_view_interval(*params["v_intervalx"])
+        self.set_rotate_label(rotate_label)
+        self._init3d()  # Inline after init3d deprecation elapses.
+
+    __init__.__signature__ = inspect.signature(_new_init)
+    adir = _api.deprecated("3.6", pending=True)(
+        property(lambda self: self.axis_name))
+
+    def _init3d(self):
+        self.line = mlines.Line2D(
+            xdata=(0, 0), ydata=(0, 0),
+            linewidth=self._axinfo['axisline']['linewidth'],
+            color=self._axinfo['axisline']['color'],
+            antialiased=True)
+
+        # Store dummy data in Polygon object
+        self.pane = mpatches.Polygon([[0, 0], [0, 1]], closed=False)
+        self.set_pane_color(self._axinfo['color'])
+
+        self.axes._set_artist_props(self.line)
+        self.axes._set_artist_props(self.pane)
+        self.gridlines = art3d.Line3DCollection([])
+        self.axes._set_artist_props(self.gridlines)
+        self.axes._set_artist_props(self.label)
+        self.axes._set_artist_props(self.offsetText)
+        # Need to be able to place the label at the correct location
+        self.label._transform = self.axes.transData
+        self.offsetText._transform = self.axes.transData
+
+    @_api.deprecated("3.6", pending=True)
+    def init3d(self):  # After deprecation elapses, inline _init3d to __init__.
+        self._init3d()
+
+    def get_major_ticks(self, numticks=None):
+        ticks = super().get_major_ticks(numticks)
+        for t in ticks:
+            for obj in [
+                    t.tick1line, t.tick2line, t.gridline, t.label1, t.label2]:
+                obj.set_transform(self.axes.transData)
+        return ticks
+
+    def get_minor_ticks(self, numticks=None):
+        ticks = super().get_minor_ticks(numticks)
+        for t in ticks:
+            for obj in [
+                    t.tick1line, t.tick2line, t.gridline, t.label1, t.label2]:
+                obj.set_transform(self.axes.transData)
+        return ticks
+
+    def set_ticks_position(self, position):
+        """
+        Set the ticks position.
+
+        Parameters
+        ----------
+        position : {'lower', 'upper', 'both', 'default', 'none'}
+            The position of the bolded axis lines, ticks, and tick labels.
+        """
+        if position in ['top', 'bottom']:
+            _api.warn_deprecated('3.8', name=f'{position=}',
+                                 obj_type='argument value',
+                                 alternative="'upper' or 'lower'")
+            return
+        _api.check_in_list(['lower', 'upper', 'both', 'default', 'none'],
+                           position=position)
+        self._tick_position = position
+
+    def get_ticks_position(self):
+        """
+        Get the ticks position.
+
+        Returns
+        -------
+        str : {'lower', 'upper', 'both', 'default', 'none'}
+            The position of the bolded axis lines, ticks, and tick labels.
+        """
+        return self._tick_position
+
+    def set_label_position(self, position):
+        """
+        Set the label position.
+
+        Parameters
+        ----------
+        position : {'lower', 'upper', 'both', 'default', 'none'}
+            The position of the axis label.
+        """
+        if position in ['top', 'bottom']:
+            _api.warn_deprecated('3.8', name=f'{position=}',
+                                 obj_type='argument value',
+                                 alternative="'upper' or 'lower'")
+            return
+        _api.check_in_list(['lower', 'upper', 'both', 'default', 'none'],
+                           position=position)
+        self._label_position = position
+
+    def get_label_position(self):
+        """
+        Get the label position.
+
+        Returns
+        -------
+        str : {'lower', 'upper', 'both', 'default', 'none'}
+            The position of the axis label.
+        """
+        return self._label_position
+
+    def set_pane_color(self, color, alpha=None):
+        """
+        Set pane color.
+
+        Parameters
+        ----------
+        color : :mpltype:`color`
+            Color for axis pane.
+        alpha : float, optional
+            Alpha value for axis pane. If None, base it on *color*.
+        """
+        color = mcolors.to_rgba(color, alpha)
+        self._axinfo['color'] = color
+        self.pane.set_edgecolor(color)
+        self.pane.set_facecolor(color)
+        self.pane.set_alpha(color[-1])
+        self.stale = True
+
+    def set_rotate_label(self, val):
+        """
+        Whether to rotate the axis label: True, False or None.
+        If set to None the label will be rotated if longer than 4 chars.
+        """
+        self._rotate_label = val
+        self.stale = True
+
+    def get_rotate_label(self, text):
+        if self._rotate_label is not None:
+            return self._rotate_label
+        else:
+            return len(text) > 4
+
+    def _get_coord_info(self):
+        mins, maxs = np.array([
+            self.axes.get_xbound(),
+            self.axes.get_ybound(),
+            self.axes.get_zbound(),
+        ]).T
+
+        # Project the bounds along the current position of the cube:
+        bounds = mins[0], maxs[0], mins[1], maxs[1], mins[2], maxs[2]
+        bounds_proj = self.axes._transformed_cube(bounds)
+
+        # Determine which one of the parallel planes are higher up:
+        means_z0 = np.zeros(3)
+        means_z1 = np.zeros(3)
+        for i in range(3):
+            means_z0[i] = np.mean(bounds_proj[self._PLANES[2 * i], 2])
+            means_z1[i] = np.mean(bounds_proj[self._PLANES[2 * i + 1], 2])
+        highs = means_z0 < means_z1
+
+        # Special handling for edge-on views
+        equals = np.abs(means_z0 - means_z1) <= np.finfo(float).eps
+        if np.sum(equals) == 2:
+            vertical = np.where(~equals)[0][0]
+            if vertical == 2:  # looking at XY plane
+                highs = np.array([True, True, highs[2]])
+            elif vertical == 1:  # looking at XZ plane
+                highs = np.array([True, highs[1], False])
+            elif vertical == 0:  # looking at YZ plane
+                highs = np.array([highs[0], False, False])
+
+        return mins, maxs, bounds_proj, highs
+
+    def _calc_centers_deltas(self, maxs, mins):
+        centers = 0.5 * (maxs + mins)
+        # In mpl3.8, the scale factor was 1/12. mpl3.9 changes this to
+        # 1/12 * 24/25 = 0.08 to compensate for the change in automargin
+        # behavior and keep appearance the same. The 24/25 factor is from the
+        # 1/48 padding added to each side of the axis in mpl3.8.
+        scale = 0.08
+        deltas = (maxs - mins) * scale
+        return centers, deltas
+
+    def _get_axis_line_edge_points(self, minmax, maxmin, position=None):
+        """Get the edge points for the black bolded axis line."""
+        # When changing vertical axis some of the axes has to be
+        # moved to the other plane so it looks the same as if the z-axis
+        # was the vertical axis.
+        mb = [minmax, maxmin]  # line from origin to nearest corner to camera
+        mb_rev = mb[::-1]
+        mm = [[mb, mb_rev, mb_rev], [mb_rev, mb_rev, mb], [mb, mb, mb]]
+        mm = mm[self.axes._vertical_axis][self._axinfo["i"]]
+
+        juggled = self._axinfo["juggled"]
+        edge_point_0 = mm[0].copy()  # origin point
+
+        if ((position == 'lower' and mm[1][juggled[-1]] < mm[0][juggled[-1]]) or
+                (position == 'upper' and mm[1][juggled[-1]] > mm[0][juggled[-1]])):
+            edge_point_0[juggled[-1]] = mm[1][juggled[-1]]
+        else:
+            edge_point_0[juggled[0]] = mm[1][juggled[0]]
+
+        edge_point_1 = edge_point_0.copy()
+        edge_point_1[juggled[1]] = mm[1][juggled[1]]
+
+        return edge_point_0, edge_point_1
+
+    def _get_all_axis_line_edge_points(self, minmax, maxmin, axis_position=None):
+        # Determine edge points for the axis lines
+        edgep1s = []
+        edgep2s = []
+        position = []
+        if axis_position in (None, 'default'):
+            edgep1, edgep2 = self._get_axis_line_edge_points(minmax, maxmin)
+            edgep1s = [edgep1]
+            edgep2s = [edgep2]
+            position = ['default']
+        else:
+            edgep1_l, edgep2_l = self._get_axis_line_edge_points(minmax, maxmin,
+                                                                 position='lower')
+            edgep1_u, edgep2_u = self._get_axis_line_edge_points(minmax, maxmin,
+                                                                 position='upper')
+            if axis_position in ('lower', 'both'):
+                edgep1s.append(edgep1_l)
+                edgep2s.append(edgep2_l)
+                position.append('lower')
+            if axis_position in ('upper', 'both'):
+                edgep1s.append(edgep1_u)
+                edgep2s.append(edgep2_u)
+                position.append('upper')
+        return edgep1s, edgep2s, position
+
+    def _get_tickdir(self, position):
+        """
+        Get the direction of the tick.
+
+        Parameters
+        ----------
+        position : str, optional : {'upper', 'lower', 'default'}
+            The position of the axis.
+
+        Returns
+        -------
+        tickdir : int
+            Index which indicates which coordinate the tick line will
+            align with.
+        """
+        _api.check_in_list(('upper', 'lower', 'default'), position=position)
+
+        # TODO: Move somewhere else where it's triggered less:
+        tickdirs_base = [v["tickdir"] for v in self._AXINFO.values()]  # default
+        elev_mod = np.mod(self.axes.elev + 180, 360) - 180
+        azim_mod = np.mod(self.axes.azim, 360)
+        if position == 'upper':
+            if elev_mod >= 0:
+                tickdirs_base = [2, 2, 0]
+            else:
+                tickdirs_base = [1, 0, 0]
+            if 0 <= azim_mod < 180:
+                tickdirs_base[2] = 1
+        elif position == 'lower':
+            if elev_mod >= 0:
+                tickdirs_base = [1, 0, 1]
+            else:
+                tickdirs_base = [2, 2, 1]
+            if 0 <= azim_mod < 180:
+                tickdirs_base[2] = 0
+        info_i = [v["i"] for v in self._AXINFO.values()]
+
+        i = self._axinfo["i"]
+        vert_ax = self.axes._vertical_axis
+        j = vert_ax - 2
+        # default: tickdir = [[1, 2, 1], [2, 2, 0], [1, 0, 0]][vert_ax][i]
+        tickdir = np.roll(info_i, -j)[np.roll(tickdirs_base, j)][i]
+        return tickdir
+
+    def active_pane(self):
+        mins, maxs, tc, highs = self._get_coord_info()
+        info = self._axinfo
+        index = info['i']
+        if not highs[index]:
+            loc = mins[index]
+            plane = self._PLANES[2 * index]
+        else:
+            loc = maxs[index]
+            plane = self._PLANES[2 * index + 1]
+        xys = np.array([tc[p] for p in plane])
+        return xys, loc
+
+    def draw_pane(self, renderer):
+        """
+        Draw pane.
+
+        Parameters
+        ----------
+        renderer : `~matplotlib.backend_bases.RendererBase` subclass
+        """
+        renderer.open_group('pane3d', gid=self.get_gid())
+        xys, loc = self.active_pane()
+        self.pane.xy = xys[:, :2]
+        self.pane.draw(renderer)
+        renderer.close_group('pane3d')
+
+    def _axmask(self):
+        axmask = [True, True, True]
+        axmask[self._axinfo["i"]] = False
+        return axmask
+
+    def _draw_ticks(self, renderer, edgep1, centers, deltas, highs,
+                    deltas_per_point, pos):
+        ticks = self._update_ticks()
+        info = self._axinfo
+        index = info["i"]
+        juggled = info["juggled"]
+
+        mins, maxs, tc, highs = self._get_coord_info()
+        centers, deltas = self._calc_centers_deltas(maxs, mins)
+
+        # Draw ticks:
+        tickdir = self._get_tickdir(pos)
+        tickdelta = deltas[tickdir] if highs[tickdir] else -deltas[tickdir]
+
+        tick_info = info['tick']
+        tick_out = tick_info['outward_factor'] * tickdelta
+        tick_in = tick_info['inward_factor'] * tickdelta
+        tick_lw = tick_info['linewidth']
+        edgep1_tickdir = edgep1[tickdir]
+        out_tickdir = edgep1_tickdir + tick_out
+        in_tickdir = edgep1_tickdir - tick_in
+
+        default_label_offset = 8.  # A rough estimate
+        points = deltas_per_point * deltas
+        for tick in ticks:
+            # Get tick line positions
+            pos = edgep1.copy()
+            pos[index] = tick.get_loc()
+            pos[tickdir] = out_tickdir
+            x1, y1, z1 = proj3d.proj_transform(*pos, self.axes.M)
+            pos[tickdir] = in_tickdir
+            x2, y2, z2 = proj3d.proj_transform(*pos, self.axes.M)
+
+            # Get position of label
+            labeldeltas = (tick.get_pad() + default_label_offset) * points
+
+            pos[tickdir] = edgep1_tickdir
+            pos = _move_from_center(pos, centers, labeldeltas, self._axmask())
+            lx, ly, lz = proj3d.proj_transform(*pos, self.axes.M)
+
+            _tick_update_position(tick, (x1, x2), (y1, y2), (lx, ly))
+            tick.tick1line.set_linewidth(tick_lw[tick._major])
+            tick.draw(renderer)
+
+    def _draw_offset_text(self, renderer, edgep1, edgep2, labeldeltas, centers,
+                          highs, pep, dx, dy):
+        # Get general axis information:
+        info = self._axinfo
+        index = info["i"]
+        juggled = info["juggled"]
+        tickdir = info["tickdir"]
+
+        # Which of the two edge points do we want to
+        # use for locating the offset text?
+        if juggled[2] == 2:
+            outeredgep = edgep1
+            outerindex = 0
+        else:
+            outeredgep = edgep2
+            outerindex = 1
+
+        pos = _move_from_center(outeredgep, centers, labeldeltas,
+                                self._axmask())
+        olx, oly, olz = proj3d.proj_transform(*pos, self.axes.M)
+        self.offsetText.set_text(self.major.formatter.get_offset())
+        self.offsetText.set_position((olx, oly))
+        angle = art3d._norm_text_angle(np.rad2deg(np.arctan2(dy, dx)))
+        self.offsetText.set_rotation(angle)
+        # Must set rotation mode to "anchor" so that
+        # the alignment point is used as the "fulcrum" for rotation.
+        self.offsetText.set_rotation_mode('anchor')
+
+        # ----------------------------------------------------------------------
+        # Note: the following statement for determining the proper alignment of
+        # the offset text. This was determined entirely by trial-and-error
+        # and should not be in any way considered as "the way".  There are
+        # still some edge cases where alignment is not quite right, but this
+        # seems to be more of a geometry issue (in other words, I might be
+        # using the wrong reference points).
+        #
+        # (TT, FF, TF, FT) are the shorthand for the tuple of
+        #   (centpt[tickdir] <= pep[tickdir, outerindex],
+        #    centpt[index] <= pep[index, outerindex])
+        #
+        # Three-letters (e.g., TFT, FTT) are short-hand for the array of bools
+        # from the variable 'highs'.
+        # ---------------------------------------------------------------------
+        centpt = proj3d.proj_transform(*centers, self.axes.M)
+        if centpt[tickdir] > pep[tickdir, outerindex]:
+            # if FT and if highs has an even number of Trues
+            if (centpt[index] <= pep[index, outerindex]
+                    and np.count_nonzero(highs) % 2 == 0):
+                # Usually, this means align right, except for the FTT case,
+                # in which offset for axis 1 and 2 are aligned left.
+                if highs.tolist() == [False, True, True] and index in (1, 2):
+                    align = 'left'
+                else:
+                    align = 'right'
+            else:
+                # The FF case
+                align = 'left'
+        else:
+            # if TF and if highs has an even number of Trues
+            if (centpt[index] > pep[index, outerindex]
+                    and np.count_nonzero(highs) % 2 == 0):
+                # Usually mean align left, except if it is axis 2
+                align = 'right' if index == 2 else 'left'
+            else:
+                # The TT case
+                align = 'right'
+
+        self.offsetText.set_va('center')
+        self.offsetText.set_ha(align)
+        self.offsetText.draw(renderer)
+
+    def _draw_labels(self, renderer, edgep1, edgep2, labeldeltas, centers, dx, dy):
+        label = self._axinfo["label"]
+
+        # Draw labels
+        lxyz = 0.5 * (edgep1 + edgep2)
+        lxyz = _move_from_center(lxyz, centers, labeldeltas, self._axmask())
+        tlx, tly, tlz = proj3d.proj_transform(*lxyz, self.axes.M)
+        self.label.set_position((tlx, tly))
+        if self.get_rotate_label(self.label.get_text()):
+            angle = art3d._norm_text_angle(np.rad2deg(np.arctan2(dy, dx)))
+            self.label.set_rotation(angle)
+        self.label.set_va(label['va'])
+        self.label.set_ha(label['ha'])
+        self.label.set_rotation_mode(label['rotation_mode'])
+        self.label.draw(renderer)
+
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        self.label._transform = self.axes.transData
+        self.offsetText._transform = self.axes.transData
+        renderer.open_group("axis3d", gid=self.get_gid())
+
+        # Get general axis information:
+        mins, maxs, tc, highs = self._get_coord_info()
+        centers, deltas = self._calc_centers_deltas(maxs, mins)
+
+        # Calculate offset distances
+        # A rough estimate; points are ambiguous since 3D plots rotate
+        reltoinches = self.figure.dpi_scale_trans.inverted()
+        ax_inches = reltoinches.transform(self.axes.bbox.size)
+        ax_points_estimate = sum(72. * ax_inches)
+        deltas_per_point = 48 / ax_points_estimate
+        default_offset = 21.
+        labeldeltas = (self.labelpad + default_offset) * deltas_per_point * deltas
+
+        # Determine edge points for the axis lines
+        minmax = np.where(highs, maxs, mins)  # "origin" point
+        maxmin = np.where(~highs, maxs, mins)  # "opposite" corner near camera
+
+        for edgep1, edgep2, pos in zip(*self._get_all_axis_line_edge_points(
+                                           minmax, maxmin, self._tick_position)):
+            # Project the edge points along the current position
+            pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
+            pep = np.asarray(pep)
+
+            # The transAxes transform is used because the Text object
+            # rotates the text relative to the display coordinate system.
+            # Therefore, if we want the labels to remain parallel to the
+            # axis regardless of the aspect ratio, we need to convert the
+            # edge points of the plane to display coordinates and calculate
+            # an angle from that.
+            # TODO: Maybe Text objects should handle this themselves?
+            dx, dy = (self.axes.transAxes.transform([pep[0:2, 1]]) -
+                      self.axes.transAxes.transform([pep[0:2, 0]]))[0]
+
+            # Draw the lines
+            self.line.set_data(pep[0], pep[1])
+            self.line.draw(renderer)
+
+            # Draw ticks
+            self._draw_ticks(renderer, edgep1, centers, deltas, highs,
+                             deltas_per_point, pos)
+
+            # Draw Offset text
+            self._draw_offset_text(renderer, edgep1, edgep2, labeldeltas,
+                                   centers, highs, pep, dx, dy)
+
+        for edgep1, edgep2, pos in zip(*self._get_all_axis_line_edge_points(
+                                           minmax, maxmin, self._label_position)):
+            # See comments above
+            pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
+            pep = np.asarray(pep)
+            dx, dy = (self.axes.transAxes.transform([pep[0:2, 1]]) -
+                      self.axes.transAxes.transform([pep[0:2, 0]]))[0]
+
+            # Draw labels
+            self._draw_labels(renderer, edgep1, edgep2, labeldeltas, centers, dx, dy)
+
+        renderer.close_group('axis3d')
+        self.stale = False
+
+    @artist.allow_rasterization
+    def draw_grid(self, renderer):
+        if not self.axes._draw_grid:
+            return
+
+        renderer.open_group("grid3d", gid=self.get_gid())
+
+        ticks = self._update_ticks()
+        if len(ticks):
+            # Get general axis information:
+            info = self._axinfo
+            index = info["i"]
+
+            mins, maxs, tc, highs = self._get_coord_info()
+
+            minmax = np.where(highs, maxs, mins)
+            maxmin = np.where(~highs, maxs, mins)
+
+            # Grid points where the planes meet
+            xyz0 = np.tile(minmax, (len(ticks), 1))
+            xyz0[:, index] = [tick.get_loc() for tick in ticks]
+
+            # Grid lines go from the end of one plane through the plane
+            # intersection (at xyz0) to the end of the other plane.  The first
+            # point (0) differs along dimension index-2 and the last (2) along
+            # dimension index-1.
+            lines = np.stack([xyz0, xyz0, xyz0], axis=1)
+            lines[:, 0, index - 2] = maxmin[index - 2]
+            lines[:, 2, index - 1] = maxmin[index - 1]
+            self.gridlines.set_segments(lines)
+            gridinfo = info['grid']
+            self.gridlines.set_color(gridinfo['color'])
+            self.gridlines.set_linewidth(gridinfo['linewidth'])
+            self.gridlines.set_linestyle(gridinfo['linestyle'])
+            self.gridlines.do_3d_projection()
+            self.gridlines.draw(renderer)
+
+        renderer.close_group('grid3d')
+
+    # TODO: Get this to work (more) properly when mplot3d supports the
+    #       transforms framework.
+    def get_tightbbox(self, renderer=None, *, for_layout_only=False):
+        # docstring inherited
+        if not self.get_visible():
+            return
+        # We have to directly access the internal data structures
+        # (and hope they are up to date) because at draw time we
+        # shift the ticks and their labels around in (x, y) space
+        # based on the projection, the current view port, and their
+        # position in 3D space. If we extend the transforms framework
+        # into 3D we would not need to do this different book keeping
+        # than we do in the normal axis
+        major_locs = self.get_majorticklocs()
+        minor_locs = self.get_minorticklocs()
+
+        ticks = [*self.get_minor_ticks(len(minor_locs)),
+                 *self.get_major_ticks(len(major_locs))]
+        view_low, view_high = self.get_view_interval()
+        if view_low > view_high:
+            view_low, view_high = view_high, view_low
+        interval_t = self.get_transform().transform([view_low, view_high])
+
+        ticks_to_draw = []
+        for tick in ticks:
+            try:
+                loc_t = self.get_transform().transform(tick.get_loc())
+            except AssertionError:
+                # Transform.transform doesn't allow masked values but
+                # some scales might make them, so we need this try/except.
+                pass
+            else:
+                if mtransforms._interval_contains_close(interval_t, loc_t):
+                    ticks_to_draw.append(tick)
+
+        ticks = ticks_to_draw
+
+        bb_1, bb_2 = self._get_ticklabel_bboxes(ticks, renderer)
+        other = []
+
+        if self.line.get_visible():
+            other.append(self.line.get_window_extent(renderer))
+        if (self.label.get_visible() and not for_layout_only and
+                self.label.get_text()):
+            other.append(self.label.get_window_extent(renderer))
+
+        return mtransforms.Bbox.union([*bb_1, *bb_2, *other])
+
+    d_interval = _api.deprecated(
+        "3.6", alternative="get_data_interval", pending=True)(
+            property(lambda self: self.get_data_interval(),
+                     lambda self, minmax: self.set_data_interval(*minmax)))
+    v_interval = _api.deprecated(
+        "3.6", alternative="get_view_interval", pending=True)(
+            property(lambda self: self.get_view_interval(),
+                     lambda self, minmax: self.set_view_interval(*minmax)))
+
+
+class XAxis(Axis):
+    axis_name = "x"
+    get_view_interval, set_view_interval = maxis._make_getset_interval(
+        "view", "xy_viewLim", "intervalx")
+    get_data_interval, set_data_interval = maxis._make_getset_interval(
+        "data", "xy_dataLim", "intervalx")
+
+
+class YAxis(Axis):
+    axis_name = "y"
+    get_view_interval, set_view_interval = maxis._make_getset_interval(
+        "view", "xy_viewLim", "intervaly")
+    get_data_interval, set_data_interval = maxis._make_getset_interval(
+        "data", "xy_dataLim", "intervaly")
+
+
+class ZAxis(Axis):
+    axis_name = "z"
+    get_view_interval, set_view_interval = maxis._make_getset_interval(
+        "view", "zz_viewLim", "intervalx")
+    get_data_interval, set_data_interval = maxis._make_getset_interval(
+        "data", "zz_dataLim", "intervalx")
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/proj3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/proj3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..098a7b6f666701d75e906820b26f9271c27834b7
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/proj3d.py
@@ -0,0 +1,259 @@
+"""
+Various transforms used for by the 3D code
+"""
+
+import numpy as np
+
+from matplotlib import _api
+
+
+def world_transformation(xmin, xmax,
+                         ymin, ymax,
+                         zmin, zmax, pb_aspect=None):
+    """
+    Produce a matrix that scales homogeneous coords in the specified ranges
+    to [0, 1], or [0, pb_aspect[i]] if the plotbox aspect ratio is specified.
+    """
+    dx = xmax - xmin
+    dy = ymax - ymin
+    dz = zmax - zmin
+    if pb_aspect is not None:
+        ax, ay, az = pb_aspect
+        dx /= ax
+        dy /= ay
+        dz /= az
+
+    return np.array([[1/dx, 0,    0,    -xmin/dx],
+                     [0,    1/dy, 0,    -ymin/dy],
+                     [0,    0,    1/dz, -zmin/dz],
+                     [0,    0,    0,    1]])
+
+
+@_api.deprecated("3.8")
+def rotation_about_vector(v, angle):
+    """
+    Produce a rotation matrix for an angle in radians about a vector.
+    """
+    return _rotation_about_vector(v, angle)
+
+
+def _rotation_about_vector(v, angle):
+    """
+    Produce a rotation matrix for an angle in radians about a vector.
+    """
+    vx, vy, vz = v / np.linalg.norm(v)
+    s = np.sin(angle)
+    c = np.cos(angle)
+    t = 2*np.sin(angle/2)**2  # more numerically stable than t = 1-c
+
+    R = np.array([
+        [t*vx*vx + c,    t*vx*vy - vz*s, t*vx*vz + vy*s],
+        [t*vy*vx + vz*s, t*vy*vy + c,    t*vy*vz - vx*s],
+        [t*vz*vx - vy*s, t*vz*vy + vx*s, t*vz*vz + c]])
+
+    return R
+
+
+def _view_axes(E, R, V, roll):
+    """
+    Get the unit viewing axes in data coordinates.
+
+    Parameters
+    ----------
+    E : 3-element numpy array
+        The coordinates of the eye/camera.
+    R : 3-element numpy array
+        The coordinates of the center of the view box.
+    V : 3-element numpy array
+        Unit vector in the direction of the vertical axis.
+    roll : float
+        The roll angle in radians.
+
+    Returns
+    -------
+    u : 3-element numpy array
+        Unit vector pointing towards the right of the screen.
+    v : 3-element numpy array
+        Unit vector pointing towards the top of the screen.
+    w : 3-element numpy array
+        Unit vector pointing out of the screen.
+    """
+    w = (E - R)
+    w = w/np.linalg.norm(w)
+    u = np.cross(V, w)
+    u = u/np.linalg.norm(u)
+    v = np.cross(w, u)  # Will be a unit vector
+
+    # Save some computation for the default roll=0
+    if roll != 0:
+        # A positive rotation of the camera is a negative rotation of the world
+        Rroll = _rotation_about_vector(w, -roll)
+        u = np.dot(Rroll, u)
+        v = np.dot(Rroll, v)
+    return u, v, w
+
+
+def _view_transformation_uvw(u, v, w, E):
+    """
+    Return the view transformation matrix.
+
+    Parameters
+    ----------
+    u : 3-element numpy array
+        Unit vector pointing towards the right of the screen.
+    v : 3-element numpy array
+        Unit vector pointing towards the top of the screen.
+    w : 3-element numpy array
+        Unit vector pointing out of the screen.
+    E : 3-element numpy array
+        The coordinates of the eye/camera.
+    """
+    Mr = np.eye(4)
+    Mt = np.eye(4)
+    Mr[:3, :3] = [u, v, w]
+    Mt[:3, -1] = -E
+    M = np.dot(Mr, Mt)
+    return M
+
+
+@_api.deprecated("3.8")
+def view_transformation(E, R, V, roll):
+    """
+    Return the view transformation matrix.
+
+    Parameters
+    ----------
+    E : 3-element numpy array
+        The coordinates of the eye/camera.
+    R : 3-element numpy array
+        The coordinates of the center of the view box.
+    V : 3-element numpy array
+        Unit vector in the direction of the vertical axis.
+    roll : float
+        The roll angle in radians.
+    """
+    u, v, w = _view_axes(E, R, V, roll)
+    M = _view_transformation_uvw(u, v, w, E)
+    return M
+
+
+@_api.deprecated("3.8")
+def persp_transformation(zfront, zback, focal_length):
+    return _persp_transformation(zfront, zback, focal_length)
+
+
+def _persp_transformation(zfront, zback, focal_length):
+    e = focal_length
+    a = 1  # aspect ratio
+    b = (zfront+zback)/(zfront-zback)
+    c = -2*(zfront*zback)/(zfront-zback)
+    proj_matrix = np.array([[e,   0,  0, 0],
+                            [0, e/a,  0, 0],
+                            [0,   0,  b, c],
+                            [0,   0, -1, 0]])
+    return proj_matrix
+
+
+@_api.deprecated("3.8")
+def ortho_transformation(zfront, zback):
+    return _ortho_transformation(zfront, zback)
+
+
+def _ortho_transformation(zfront, zback):
+    # note: w component in the resulting vector will be (zback-zfront), not 1
+    a = -(zfront + zback)
+    b = -(zfront - zback)
+    proj_matrix = np.array([[2, 0,  0, 0],
+                            [0, 2,  0, 0],
+                            [0, 0, -2, 0],
+                            [0, 0,  a, b]])
+    return proj_matrix
+
+
+def _proj_transform_vec(vec, M):
+    vecw = np.dot(M, vec)
+    w = vecw[3]
+    # clip here..
+    txs, tys, tzs = vecw[0]/w, vecw[1]/w, vecw[2]/w
+    return txs, tys, tzs
+
+
+def _proj_transform_vec_clip(vec, M):
+    vecw = np.dot(M, vec)
+    w = vecw[3]
+    # clip here.
+    txs, tys, tzs = vecw[0] / w, vecw[1] / w, vecw[2] / w
+    tis = (0 <= vecw[0]) & (vecw[0] <= 1) & (0 <= vecw[1]) & (vecw[1] <= 1)
+    if np.any(tis):
+        tis = vecw[1] < 1
+    return txs, tys, tzs, tis
+
+
+def inv_transform(xs, ys, zs, invM):
+    """
+    Transform the points by the inverse of the projection matrix, *invM*.
+    """
+    vec = _vec_pad_ones(xs, ys, zs)
+    vecr = np.dot(invM, vec)
+    if vecr.shape == (4,):
+        vecr = vecr.reshape((4, 1))
+    for i in range(vecr.shape[1]):
+        if vecr[3][i] != 0:
+            vecr[:, i] = vecr[:, i] / vecr[3][i]
+    return vecr[0], vecr[1], vecr[2]
+
+
+def _vec_pad_ones(xs, ys, zs):
+    return np.array([xs, ys, zs, np.ones_like(xs)])
+
+
+def proj_transform(xs, ys, zs, M):
+    """
+    Transform the points by the projection matrix *M*.
+    """
+    vec = _vec_pad_ones(xs, ys, zs)
+    return _proj_transform_vec(vec, M)
+
+
+transform = _api.deprecated(
+    "3.8", obj_type="function", name="transform",
+    alternative="proj_transform")(proj_transform)
+
+
+def proj_transform_clip(xs, ys, zs, M):
+    """
+    Transform the points by the projection matrix
+    and return the clipping result
+    returns txs, tys, tzs, tis
+    """
+    vec = _vec_pad_ones(xs, ys, zs)
+    return _proj_transform_vec_clip(vec, M)
+
+
+@_api.deprecated("3.8")
+def proj_points(points, M):
+    return _proj_points(points, M)
+
+
+def _proj_points(points, M):
+    return np.column_stack(_proj_trans_points(points, M))
+
+
+@_api.deprecated("3.8")
+def proj_trans_points(points, M):
+    return _proj_trans_points(points, M)
+
+
+def _proj_trans_points(points, M):
+    xs, ys, zs = zip(*points)
+    return proj_transform(xs, ys, zs, M)
+
+
+@_api.deprecated("3.8")
+def rot_x(V, alpha):
+    cosa, sina = np.cos(alpha), np.sin(alpha)
+    M1 = np.array([[1, 0, 0, 0],
+                   [0, cosa, -sina, 0],
+                   [0, sina, cosa, 0],
+                   [0, 0, 0, 1]])
+    return np.dot(M1, V)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__init__.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea4d8ed16a6a24a8c15ab2956ef678a7f256cd80
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__init__.py
@@ -0,0 +1,10 @@
+from pathlib import Path
+
+
+# Check that the test directories exist
+if not (Path(__file__).parent / "baseline_images").exists():
+    raise OSError(
+        'The baseline image directory does not exist. '
+        'This is most likely because the test data is not installed. '
+        'You may need to install matplotlib from source to get the '
+        'test data.')
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/__init__.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de33c2d8aa032bb05a552ff4bc17d0aea957f47e
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/conftest.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/conftest.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..815af3c968c8720ecb093c04af4c0ce403ed8c6e
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/conftest.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_art3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_art3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb3c64d2e387283ace51216845c91b51ea09f94f
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_art3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_axes3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_axes3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52b3563b32b5fc30e4f62f96af4684a8ed5fee5a
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_axes3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_legend3d.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_legend3d.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7464c78790889287b20f4fd630581904973f8d3
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_legend3d.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/conftest.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..61c2de3e07bac4db323f8704961264d123e01544
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/conftest.py
@@ -0,0 +1,2 @@
+from matplotlib.testing.conftest import (mpl_test_settings,  # noqa
+                                         pytest_configure, pytest_unconfigure)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_art3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_art3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ed48aae46858555f8813fbbff9e573587ea45b0
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_art3d.py
@@ -0,0 +1,56 @@
+import numpy as np
+
+import matplotlib.pyplot as plt
+
+from matplotlib.backend_bases import MouseEvent
+from mpl_toolkits.mplot3d.art3d import Line3DCollection
+
+
+def test_scatter_3d_projection_conservation():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    # fix axes3d projection
+    ax.roll = 0
+    ax.elev = 0
+    ax.azim = -45
+    ax.stale = True
+
+    x = [0, 1, 2, 3, 4]
+    scatter_collection = ax.scatter(x, x, x)
+    fig.canvas.draw_idle()
+
+    # Get scatter location on canvas and freeze the data
+    scatter_offset = scatter_collection.get_offsets()
+    scatter_location = ax.transData.transform(scatter_offset)
+
+    # Yaw -44 and -46 are enough to produce two set of scatter
+    # with opposite z-order without moving points too far
+    for azim in (-44, -46):
+        ax.azim = azim
+        ax.stale = True
+        fig.canvas.draw_idle()
+
+        for i in range(5):
+            # Create a mouse event used to locate and to get index
+            # from each dots
+            event = MouseEvent("button_press_event", fig.canvas,
+                               *scatter_location[i, :])
+            contains, ind = scatter_collection.contains(event)
+            assert contains is True
+            assert len(ind["ind"]) == 1
+            assert ind["ind"][0] == i
+
+
+def test_zordered_error():
+    # Smoke test for https://github.com/matplotlib/matplotlib/issues/26497
+    lc = [(np.fromiter([0.0, 0.0, 0.0], dtype="float"),
+           np.fromiter([1.0, 1.0, 1.0], dtype="float"))]
+    pc = [np.fromiter([0.0, 0.0], dtype="float"),
+          np.fromiter([0.0, 1.0], dtype="float"),
+          np.fromiter([1.0, 1.0], dtype="float")]
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection="3d")
+    ax.add_collection(Line3DCollection(lc))
+    ax.scatter(*pc, visible=False)
+    plt.draw()
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_axes3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_axes3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..ecb51b724c27a2f325b278b9d58d4be6f5cf94c9
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_axes3d.py
@@ -0,0 +1,2452 @@
+import functools
+import itertools
+import platform
+
+import pytest
+
+from mpl_toolkits.mplot3d import Axes3D, axes3d, proj3d, art3d
+import matplotlib as mpl
+from matplotlib.backend_bases import (MouseButton, MouseEvent,
+                                      NavigationToolbar2)
+from matplotlib import cm
+from matplotlib import colors as mcolors, patches as mpatch
+from matplotlib.testing.decorators import image_comparison, check_figures_equal
+from matplotlib.testing.widgets import mock_event
+from matplotlib.collections import LineCollection, PolyCollection
+from matplotlib.patches import Circle, PathPatch
+from matplotlib.path import Path
+from matplotlib.text import Text
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+mpl3d_image_comparison = functools.partial(
+    image_comparison, remove_text=True, style='default')
+
+
+def plot_cuboid(ax, scale):
+    # plot a rectangular cuboid with side lengths given by scale (x, y, z)
+    r = [0, 1]
+    pts = itertools.combinations(np.array(list(itertools.product(r, r, r))), 2)
+    for start, end in pts:
+        if np.sum(np.abs(start - end)) == r[1] - r[0]:
+            ax.plot3D(*zip(start*np.array(scale), end*np.array(scale)))
+
+
+@check_figures_equal(extensions=["png"])
+def test_invisible_axes(fig_test, fig_ref):
+    ax = fig_test.subplots(subplot_kw=dict(projection='3d'))
+    ax.set_visible(False)
+
+
+@mpl3d_image_comparison(['grid_off.png'], style='mpl20')
+def test_grid_off():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.grid(False)
+
+
+@mpl3d_image_comparison(['invisible_ticks_axis.png'], style='mpl20')
+def test_invisible_ticks_axis():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_zticks([])
+    for axis in [ax.xaxis, ax.yaxis, ax.zaxis]:
+        axis.line.set_visible(False)
+
+
+@mpl3d_image_comparison(['axis_positions.png'], remove_text=False, style='mpl20')
+def test_axis_positions():
+    positions = ['upper', 'lower', 'both', 'none']
+    fig, axs = plt.subplots(2, 2, subplot_kw={'projection': '3d'})
+    for ax, pos in zip(axs.flatten(), positions):
+        for axis in ax.xaxis, ax.yaxis, ax.zaxis:
+            axis.set_label_position(pos)
+            axis.set_ticks_position(pos)
+        title = f'{pos}'
+        ax.set(xlabel='x', ylabel='y', zlabel='z', title=title)
+
+
+@mpl3d_image_comparison(['aspects.png'], remove_text=False, style='mpl20')
+def test_aspects():
+    aspects = ('auto', 'equal', 'equalxy', 'equalyz', 'equalxz', 'equal')
+    _, axs = plt.subplots(2, 3, subplot_kw={'projection': '3d'})
+
+    for ax in axs.flatten()[0:-1]:
+        plot_cuboid(ax, scale=[1, 1, 5])
+    # plot a cube as well to cover github #25443
+    plot_cuboid(axs[1][2], scale=[1, 1, 1])
+
+    for i, ax in enumerate(axs.flatten()):
+        ax.set_title(aspects[i])
+        ax.set_box_aspect((3, 4, 5))
+        ax.set_aspect(aspects[i], adjustable='datalim')
+    axs[1][2].set_title('equal (cube)')
+
+
+@mpl3d_image_comparison(['aspects_adjust_box.png'],
+                        remove_text=False, style='mpl20')
+def test_aspects_adjust_box():
+    aspects = ('auto', 'equal', 'equalxy', 'equalyz', 'equalxz')
+    fig, axs = plt.subplots(1, len(aspects), subplot_kw={'projection': '3d'},
+                            figsize=(11, 3))
+
+    for i, ax in enumerate(axs):
+        plot_cuboid(ax, scale=[4, 3, 5])
+        ax.set_title(aspects[i])
+        ax.set_aspect(aspects[i], adjustable='box')
+
+
+def test_axes3d_repr():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_label('label')
+    ax.set_title('title')
+    ax.set_xlabel('x')
+    ax.set_ylabel('y')
+    ax.set_zlabel('z')
+    assert repr(ax) == (
+        "<Axes3D: label='label', "
+        "title={'center': 'title'}, xlabel='x', ylabel='y', zlabel='z'>")
+
+
+@mpl3d_image_comparison(['axes3d_primary_views.png'], style='mpl20',
+                        tol=0.05 if platform.machine() == "arm64" else 0)
+def test_axes3d_primary_views():
+    # (elev, azim, roll)
+    views = [(90, -90, 0),  # XY
+             (0, -90, 0),   # XZ
+             (0, 0, 0),     # YZ
+             (-90, 90, 0),  # -XY
+             (0, 90, 0),    # -XZ
+             (0, 180, 0)]   # -YZ
+    # When viewing primary planes, draw the two visible axes so they intersect
+    # at their low values
+    fig, axs = plt.subplots(2, 3, subplot_kw={'projection': '3d'})
+    for i, ax in enumerate(axs.flat):
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        ax.set_zlabel('z')
+        ax.set_proj_type('ortho')
+        ax.view_init(elev=views[i][0], azim=views[i][1], roll=views[i][2])
+    plt.tight_layout()
+
+
+@mpl3d_image_comparison(['bar3d.png'], style='mpl20')
+def test_bar3d():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    for c, z in zip(['r', 'g', 'b', 'y'], [30, 20, 10, 0]):
+        xs = np.arange(20)
+        ys = np.arange(20)
+        cs = [c] * len(xs)
+        cs[0] = 'c'
+        ax.bar(xs, ys, zs=z, zdir='y', align='edge', color=cs, alpha=0.8)
+
+
+def test_bar3d_colors():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    for c in ['red', 'green', 'blue', 'yellow']:
+        xs = np.arange(len(c))
+        ys = np.zeros_like(xs)
+        zs = np.zeros_like(ys)
+        # Color names with same length as xs/ys/zs should not be split into
+        # individual letters.
+        ax.bar3d(xs, ys, zs, 1, 1, 1, color=c)
+
+
+@mpl3d_image_comparison(['bar3d_shaded.png'], style='mpl20')
+def test_bar3d_shaded():
+    x = np.arange(4)
+    y = np.arange(5)
+    x2d, y2d = np.meshgrid(x, y)
+    x2d, y2d = x2d.ravel(), y2d.ravel()
+    z = x2d + y2d + 1  # Avoid triggering bug with zero-depth boxes.
+
+    views = [(30, -60, 0), (30, 30, 30), (-30, 30, -90), (300, -30, 0)]
+    fig = plt.figure(figsize=plt.figaspect(1 / len(views)))
+    axs = fig.subplots(
+        1, len(views),
+        subplot_kw=dict(projection='3d')
+    )
+    for ax, (elev, azim, roll) in zip(axs, views):
+        ax.bar3d(x2d, y2d, x2d * 0, 1, 1, z, shade=True)
+        ax.view_init(elev=elev, azim=azim, roll=roll)
+    fig.canvas.draw()
+
+
+@mpl3d_image_comparison(['bar3d_notshaded.png'], style='mpl20')
+def test_bar3d_notshaded():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    x = np.arange(4)
+    y = np.arange(5)
+    x2d, y2d = np.meshgrid(x, y)
+    x2d, y2d = x2d.ravel(), y2d.ravel()
+    z = x2d + y2d
+    ax.bar3d(x2d, y2d, x2d * 0, 1, 1, z, shade=False)
+    fig.canvas.draw()
+
+
+def test_bar3d_lightsource():
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1, projection="3d")
+
+    ls = mcolors.LightSource(azdeg=0, altdeg=90)
+
+    length, width = 3, 4
+    area = length * width
+
+    x, y = np.meshgrid(np.arange(length), np.arange(width))
+    x = x.ravel()
+    y = y.ravel()
+    dz = x + y
+
+    color = [cm.coolwarm(i/area) for i in range(area)]
+
+    collection = ax.bar3d(x=x, y=y, z=0,
+                          dx=1, dy=1, dz=dz,
+                          color=color, shade=True, lightsource=ls)
+
+    # Testing that the custom 90° lightsource produces different shading on
+    # the top facecolors compared to the default, and that those colors are
+    # precisely (within floating point rounding errors of 4 ULP) the colors
+    # from the colormap, due to the illumination parallel to the z-axis.
+    np.testing.assert_array_max_ulp(color, collection._facecolor3d[1::6], 4)
+
+
+@mpl3d_image_comparison(
+    ['contour3d.png'], style='mpl20',
+    tol=0.002 if platform.machine() in ('aarch64', 'ppc64le', 's390x') else 0)
+def test_contour3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)
+    ax.contour(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)
+    ax.contour(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)
+    ax.axis(xmin=-40, xmax=40, ymin=-40, ymax=40, zmin=-100, zmax=100)
+
+
+@mpl3d_image_comparison(['contour3d_extend3d.png'], style='mpl20')
+def test_contour3d_extend3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.contour(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm, extend3d=True)
+    ax.set_xlim(-30, 30)
+    ax.set_ylim(-20, 40)
+    ax.set_zlim(-80, 80)
+
+
+@mpl3d_image_comparison(['contourf3d.png'], style='mpl20')
+def test_contourf3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.contourf(X, Y, Z, zdir='z', offset=-100, cmap=cm.coolwarm)
+    ax.contourf(X, Y, Z, zdir='x', offset=-40, cmap=cm.coolwarm)
+    ax.contourf(X, Y, Z, zdir='y', offset=40, cmap=cm.coolwarm)
+    ax.set_xlim(-40, 40)
+    ax.set_ylim(-40, 40)
+    ax.set_zlim(-100, 100)
+
+
+@mpl3d_image_comparison(['contourf3d_fill.png'], style='mpl20')
+def test_contourf3d_fill():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y = np.meshgrid(np.arange(-2, 2, 0.25), np.arange(-2, 2, 0.25))
+    Z = X.clip(0, 0)
+    # This produces holes in the z=0 surface that causes rendering errors if
+    # the Poly3DCollection is not aware of path code information (issue #4784)
+    Z[::5, ::5] = 0.1
+    ax.contourf(X, Y, Z, offset=0, levels=[-0.1, 0], cmap=cm.coolwarm)
+    ax.set_xlim(-2, 2)
+    ax.set_ylim(-2, 2)
+    ax.set_zlim(-1, 1)
+
+
+@pytest.mark.parametrize('extend, levels', [['both', [2, 4, 6]],
+                                            ['min', [2, 4, 6, 8]],
+                                            ['max', [0, 2, 4, 6]]])
+@check_figures_equal(extensions=["png"])
+def test_contourf3d_extend(fig_test, fig_ref, extend, levels):
+    X, Y = np.meshgrid(np.arange(-2, 2, 0.25), np.arange(-2, 2, 0.25))
+    # Z is in the range [0, 8]
+    Z = X**2 + Y**2
+
+    # Manually set the over/under colors to be the end of the colormap
+    cmap = mpl.colormaps['viridis'].copy()
+    cmap.set_under(cmap(0))
+    cmap.set_over(cmap(255))
+    # Set vmin/max to be the min/max values plotted on the reference image
+    kwargs = {'vmin': 1, 'vmax': 7, 'cmap': cmap}
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.contourf(X, Y, Z, levels=[0, 2, 4, 6, 8], **kwargs)
+
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.contourf(X, Y, Z, levels, extend=extend, **kwargs)
+
+    for ax in [ax_ref, ax_test]:
+        ax.set_xlim(-2, 2)
+        ax.set_ylim(-2, 2)
+        ax.set_zlim(-10, 10)
+
+
+@mpl3d_image_comparison(['tricontour.png'], tol=0.02, style='mpl20')
+def test_tricontour():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+
+    np.random.seed(19680801)
+    x = np.random.rand(1000) - 0.5
+    y = np.random.rand(1000) - 0.5
+    z = -(x**2 + y**2)
+
+    ax = fig.add_subplot(1, 2, 1, projection='3d')
+    ax.tricontour(x, y, z)
+    ax = fig.add_subplot(1, 2, 2, projection='3d')
+    ax.tricontourf(x, y, z)
+
+
+def test_contour3d_1d_input():
+    # Check that 1D sequences of different length for {x, y} doesn't error
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    nx, ny = 30, 20
+    x = np.linspace(-10, 10, nx)
+    y = np.linspace(-10, 10, ny)
+    z = np.random.randint(0, 2, [ny, nx])
+    ax.contour(x, y, z, [0.5])
+
+
+@mpl3d_image_comparison(['lines3d.png'], style='mpl20')
+def test_lines3d():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
+    z = np.linspace(-2, 2, 100)
+    r = z ** 2 + 1
+    x = r * np.sin(theta)
+    y = r * np.cos(theta)
+    ax.plot(x, y, z)
+
+
+@check_figures_equal(extensions=["png"])
+def test_plot_scalar(fig_test, fig_ref):
+    ax1 = fig_test.add_subplot(projection='3d')
+    ax1.plot([1], [1], "o")
+    ax2 = fig_ref.add_subplot(projection='3d')
+    ax2.plot(1, 1, "o")
+
+
+def test_invalid_line_data():
+    with pytest.raises(RuntimeError, match='x must be'):
+        art3d.Line3D(0, [], [])
+    with pytest.raises(RuntimeError, match='y must be'):
+        art3d.Line3D([], 0, [])
+    with pytest.raises(RuntimeError, match='z must be'):
+        art3d.Line3D([], [], 0)
+
+    line = art3d.Line3D([], [], [])
+    with pytest.raises(RuntimeError, match='x must be'):
+        line.set_data_3d(0, [], [])
+    with pytest.raises(RuntimeError, match='y must be'):
+        line.set_data_3d([], 0, [])
+    with pytest.raises(RuntimeError, match='z must be'):
+        line.set_data_3d([], [], 0)
+
+
+@mpl3d_image_comparison(['mixedsubplot.png'], style='mpl20')
+def test_mixedsubplots():
+    def f(t):
+        return np.cos(2*np.pi*t) * np.exp(-t)
+
+    t1 = np.arange(0.0, 5.0, 0.1)
+    t2 = np.arange(0.0, 5.0, 0.02)
+
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure(figsize=plt.figaspect(2.))
+    ax = fig.add_subplot(2, 1, 1)
+    ax.plot(t1, f(t1), 'bo', t2, f(t2), 'k--', markerfacecolor='green')
+    ax.grid(True)
+
+    ax = fig.add_subplot(2, 1, 2, projection='3d')
+    X, Y = np.meshgrid(np.arange(-5, 5, 0.25), np.arange(-5, 5, 0.25))
+    R = np.hypot(X, Y)
+    Z = np.sin(R)
+
+    ax.plot_surface(X, Y, Z, rcount=40, ccount=40,
+                    linewidth=0, antialiased=False)
+
+    ax.set_zlim3d(-1, 1)
+
+
+@check_figures_equal(extensions=['png'])
+def test_tight_layout_text(fig_test, fig_ref):
+    # text is currently ignored in tight layout. So the order of text() and
+    # tight_layout() calls should not influence the result.
+    ax1 = fig_test.add_subplot(projection='3d')
+    ax1.text(.5, .5, .5, s='some string')
+    fig_test.tight_layout()
+
+    ax2 = fig_ref.add_subplot(projection='3d')
+    fig_ref.tight_layout()
+    ax2.text(.5, .5, .5, s='some string')
+
+
+@mpl3d_image_comparison(['scatter3d.png'], style='mpl20')
+def test_scatter3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.scatter(np.arange(10), np.arange(10), np.arange(10),
+               c='r', marker='o')
+    x = y = z = np.arange(10, 20)
+    ax.scatter(x, y, z, c='b', marker='^')
+    z[-1] = 0  # Check that scatter() copies the data.
+    # Ensure empty scatters do not break.
+    ax.scatter([], [], [], c='r', marker='X')
+
+
+@mpl3d_image_comparison(['scatter3d_color.png'], style='mpl20')
+def test_scatter3d_color():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    # Check that 'none' color works; these two should overlay to produce the
+    # same as setting just `color`.
+    ax.scatter(np.arange(10), np.arange(10), np.arange(10),
+               facecolor='r', edgecolor='none', marker='o')
+    ax.scatter(np.arange(10), np.arange(10), np.arange(10),
+               facecolor='none', edgecolor='r', marker='o')
+
+    ax.scatter(np.arange(10, 20), np.arange(10, 20), np.arange(10, 20),
+               color='b', marker='s')
+
+
+@mpl3d_image_comparison(['scatter3d_linewidth.png'], style='mpl20')
+def test_scatter3d_linewidth():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    # Check that array-like linewidth can be set
+    ax.scatter(np.arange(10), np.arange(10), np.arange(10),
+               marker='o', linewidth=np.arange(10))
+
+
+@check_figures_equal(extensions=['png'])
+def test_scatter3d_linewidth_modification(fig_ref, fig_test):
+    # Changing Path3DCollection linewidths with array-like post-creation
+    # should work correctly.
+    ax_test = fig_test.add_subplot(projection='3d')
+    c = ax_test.scatter(np.arange(10), np.arange(10), np.arange(10),
+                        marker='o')
+    c.set_linewidths(np.arange(10))
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.scatter(np.arange(10), np.arange(10), np.arange(10), marker='o',
+                   linewidths=np.arange(10))
+
+
+@check_figures_equal(extensions=['png'])
+def test_scatter3d_modification(fig_ref, fig_test):
+    # Changing Path3DCollection properties post-creation should work correctly.
+    ax_test = fig_test.add_subplot(projection='3d')
+    c = ax_test.scatter(np.arange(10), np.arange(10), np.arange(10),
+                        marker='o')
+    c.set_facecolor('C1')
+    c.set_edgecolor('C2')
+    c.set_alpha([0.3, 0.7] * 5)
+    assert c.get_depthshade()
+    c.set_depthshade(False)
+    assert not c.get_depthshade()
+    c.set_sizes(np.full(10, 75))
+    c.set_linewidths(3)
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.scatter(np.arange(10), np.arange(10), np.arange(10), marker='o',
+                   facecolor='C1', edgecolor='C2', alpha=[0.3, 0.7] * 5,
+                   depthshade=False, s=75, linewidths=3)
+
+
+@pytest.mark.parametrize('depthshade', [True, False])
+@check_figures_equal(extensions=['png'])
+def test_scatter3d_sorting(fig_ref, fig_test, depthshade):
+    """Test that marker properties are correctly sorted."""
+
+    y, x = np.mgrid[:10, :10]
+    z = np.arange(x.size).reshape(x.shape)
+
+    sizes = np.full(z.shape, 25)
+    sizes[0::2, 0::2] = 100
+    sizes[1::2, 1::2] = 100
+
+    facecolors = np.full(z.shape, 'C0')
+    facecolors[:5, :5] = 'C1'
+    facecolors[6:, :4] = 'C2'
+    facecolors[6:, 6:] = 'C3'
+
+    edgecolors = np.full(z.shape, 'C4')
+    edgecolors[1:5, 1:5] = 'C5'
+    edgecolors[5:9, 1:5] = 'C6'
+    edgecolors[5:9, 5:9] = 'C7'
+
+    linewidths = np.full(z.shape, 2)
+    linewidths[0::2, 0::2] = 5
+    linewidths[1::2, 1::2] = 5
+
+    x, y, z, sizes, facecolors, edgecolors, linewidths = [
+        a.flatten()
+        for a in [x, y, z, sizes, facecolors, edgecolors, linewidths]
+    ]
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    sets = (np.unique(a) for a in [sizes, facecolors, edgecolors, linewidths])
+    for s, fc, ec, lw in itertools.product(*sets):
+        subset = (
+            (sizes != s) |
+            (facecolors != fc) |
+            (edgecolors != ec) |
+            (linewidths != lw)
+        )
+        subset = np.ma.masked_array(z, subset, dtype=float)
+
+        # When depth shading is disabled, the colors are passed through as
+        # single-item lists; this triggers single path optimization. The
+        # following reshaping is a hack to disable that, since the optimization
+        # would not occur for the full scatter which has multiple colors.
+        fc = np.repeat(fc, sum(~subset.mask))
+
+        ax_ref.scatter(x, y, subset, s=s, fc=fc, ec=ec, lw=lw, alpha=1,
+                       depthshade=depthshade)
+
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.scatter(x, y, z, s=sizes, fc=facecolors, ec=edgecolors,
+                    lw=linewidths, alpha=1, depthshade=depthshade)
+
+
+@pytest.mark.parametrize('azim', [-50, 130])  # yellow first, blue first
+@check_figures_equal(extensions=['png'])
+def test_marker_draw_order_data_reversed(fig_test, fig_ref, azim):
+    """
+    Test that the draw order does not depend on the data point order.
+
+    For the given viewing angle at azim=-50, the yellow marker should be in
+    front. For azim=130, the blue marker should be in front.
+    """
+    x = [-1, 1]
+    y = [1, -1]
+    z = [0, 0]
+    color = ['b', 'y']
+    ax = fig_test.add_subplot(projection='3d')
+    ax.scatter(x, y, z, s=3500, c=color)
+    ax.view_init(elev=0, azim=azim, roll=0)
+    ax = fig_ref.add_subplot(projection='3d')
+    ax.scatter(x[::-1], y[::-1], z[::-1], s=3500, c=color[::-1])
+    ax.view_init(elev=0, azim=azim, roll=0)
+
+
+@check_figures_equal(extensions=['png'])
+def test_marker_draw_order_view_rotated(fig_test, fig_ref):
+    """
+    Test that the draw order changes with the direction.
+
+    If we rotate *azim* by 180 degrees and exchange the colors, the plot
+    plot should look the same again.
+    """
+    azim = 130
+    x = [-1, 1]
+    y = [1, -1]
+    z = [0, 0]
+    color = ['b', 'y']
+    ax = fig_test.add_subplot(projection='3d')
+    # axis are not exactly invariant under 180 degree rotation -> deactivate
+    ax.set_axis_off()
+    ax.scatter(x, y, z, s=3500, c=color)
+    ax.view_init(elev=0, azim=azim, roll=0)
+    ax = fig_ref.add_subplot(projection='3d')
+    ax.set_axis_off()
+    ax.scatter(x, y, z, s=3500, c=color[::-1])  # color reversed
+    ax.view_init(elev=0, azim=azim - 180, roll=0)  # view rotated by 180 deg
+
+
+@mpl3d_image_comparison(['plot_3d_from_2d.png'], tol=0.019, style='mpl20')
+def test_plot_3d_from_2d():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    xs = np.arange(0, 5)
+    ys = np.arange(5, 10)
+    ax.plot(xs, ys, zs=0, zdir='x')
+    ax.plot(xs, ys, zs=0, zdir='y')
+
+
+@mpl3d_image_comparison(['surface3d.png'], style='mpl20')
+def test_surface3d():
+    # Remove this line when this test image is regenerated.
+    plt.rcParams['pcolormesh.snap'] = False
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X = np.arange(-5, 5, 0.25)
+    Y = np.arange(-5, 5, 0.25)
+    X, Y = np.meshgrid(X, Y)
+    R = np.hypot(X, Y)
+    Z = np.sin(R)
+    surf = ax.plot_surface(X, Y, Z, rcount=40, ccount=40, cmap=cm.coolwarm,
+                           lw=0, antialiased=False)
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_zlim(-1.01, 1.01)
+    fig.colorbar(surf, shrink=0.5, aspect=5)
+
+
+@image_comparison(['surface3d_label_offset_tick_position.png'], style='mpl20')
+def test_surface3d_label_offset_tick_position():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax = plt.figure().add_subplot(projection="3d")
+
+    x, y = np.mgrid[0:6 * np.pi:0.25, 0:4 * np.pi:0.25]
+    z = np.sqrt(np.abs(np.cos(x) + np.cos(y)))
+
+    ax.plot_surface(x * 1e5, y * 1e6, z * 1e8, cmap='autumn', cstride=2, rstride=2)
+    ax.set_xlabel("X label")
+    ax.set_ylabel("Y label")
+    ax.set_zlabel("Z label")
+
+    ax.figure.canvas.draw()
+
+
+@mpl3d_image_comparison(['surface3d_shaded.png'], style='mpl20')
+def test_surface3d_shaded():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X = np.arange(-5, 5, 0.25)
+    Y = np.arange(-5, 5, 0.25)
+    X, Y = np.meshgrid(X, Y)
+    R = np.sqrt(X ** 2 + Y ** 2)
+    Z = np.sin(R)
+    ax.plot_surface(X, Y, Z, rstride=5, cstride=5,
+                    color=[0.25, 1, 0.25], lw=1, antialiased=False)
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_zlim(-1.01, 1.01)
+
+
+@mpl3d_image_comparison(['surface3d_masked.png'], style='mpl20')
+def test_surface3d_masked():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    y = [1, 2, 3, 4, 5, 6, 7, 8]
+
+    x, y = np.meshgrid(x, y)
+    matrix = np.array(
+        [
+            [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [-1, 1, 2, 3, 4, 4, 4, 3, 2, 1, 1],
+            [-1, -1., 4, 5, 6, 8, 6, 5, 4, 3, -1.],
+            [-1, -1., 7, 8, 11, 12, 11, 8, 7, -1., -1.],
+            [-1, -1., 8, 9, 10, 16, 10, 9, 10, 7, -1.],
+            [-1, -1., -1., 12, 16, 20, 16, 12, 11, -1., -1.],
+            [-1, -1., -1., -1., 22, 24, 22, 20, 18, -1., -1.],
+            [-1, -1., -1., -1., -1., 28, 26, 25, -1., -1., -1.],
+        ]
+    )
+    z = np.ma.masked_less(matrix, 0)
+    norm = mcolors.Normalize(vmax=z.max(), vmin=z.min())
+    colors = mpl.colormaps["plasma"](norm(z))
+    ax.plot_surface(x, y, z, facecolors=colors)
+    ax.view_init(30, -80, 0)
+
+
+@check_figures_equal(extensions=["png"])
+def test_plot_scatter_masks(fig_test, fig_ref):
+    x = np.linspace(0, 10, 100)
+    y = np.linspace(0, 10, 100)
+    z = np.sin(x) * np.cos(y)
+    mask = z > 0
+
+    z_masked = np.ma.array(z, mask=mask)
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.scatter(x, y, z_masked)
+    ax_test.plot(x, y, z_masked)
+
+    x[mask] = y[mask] = z[mask] = np.nan
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.scatter(x, y, z)
+    ax_ref.plot(x, y, z)
+
+
+@check_figures_equal(extensions=["png"])
+def test_plot_surface_None_arg(fig_test, fig_ref):
+    x, y = np.meshgrid(np.arange(5), np.arange(5))
+    z = x + y
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.plot_surface(x, y, z, facecolors=None)
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.plot_surface(x, y, z)
+
+
+@mpl3d_image_comparison(['surface3d_masked_strides.png'], style='mpl20')
+def test_surface3d_masked_strides():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    x, y = np.mgrid[-6:6.1:1, -6:6.1:1]
+    z = np.ma.masked_less(x * y, 2)
+
+    ax.plot_surface(x, y, z, rstride=4, cstride=4)
+    ax.view_init(60, -45, 0)
+
+
+@mpl3d_image_comparison(['text3d.png'], remove_text=False, style='mpl20')
+def test_text3d():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    zdirs = (None, 'x', 'y', 'z', (1, 1, 0), (1, 1, 1))
+    xs = (2, 6, 4, 9, 7, 2)
+    ys = (6, 4, 8, 7, 2, 2)
+    zs = (4, 2, 5, 6, 1, 7)
+
+    for zdir, x, y, z in zip(zdirs, xs, ys, zs):
+        label = '(%d, %d, %d), dir=%s' % (x, y, z, zdir)
+        ax.text(x, y, z, label, zdir)
+
+    ax.text(1, 1, 1, "red", color='red')
+    ax.text2D(0.05, 0.95, "2D Text", transform=ax.transAxes)
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_xlim3d(0, 10)
+    ax.set_ylim3d(0, 10)
+    ax.set_zlim3d(0, 10)
+    ax.set_xlabel('X axis')
+    ax.set_ylabel('Y axis')
+    ax.set_zlabel('Z axis')
+
+
+@check_figures_equal(extensions=['png'])
+def test_text3d_modification(fig_ref, fig_test):
+    # Modifying the Text position after the fact should work the same as
+    # setting it directly.
+    zdirs = (None, 'x', 'y', 'z', (1, 1, 0), (1, 1, 1))
+    xs = (2, 6, 4, 9, 7, 2)
+    ys = (6, 4, 8, 7, 2, 2)
+    zs = (4, 2, 5, 6, 1, 7)
+
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.set_xlim3d(0, 10)
+    ax_test.set_ylim3d(0, 10)
+    ax_test.set_zlim3d(0, 10)
+    for zdir, x, y, z in zip(zdirs, xs, ys, zs):
+        t = ax_test.text(0, 0, 0, f'({x}, {y}, {z}), dir={zdir}')
+        t.set_position_3d((x, y, z), zdir=zdir)
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.set_xlim3d(0, 10)
+    ax_ref.set_ylim3d(0, 10)
+    ax_ref.set_zlim3d(0, 10)
+    for zdir, x, y, z in zip(zdirs, xs, ys, zs):
+        ax_ref.text(x, y, z, f'({x}, {y}, {z}), dir={zdir}', zdir=zdir)
+
+
+@mpl3d_image_comparison(['trisurf3d.png'], tol=0.061, style='mpl20')
+def test_trisurf3d():
+    n_angles = 36
+    n_radii = 8
+    radii = np.linspace(0.125, 1.0, n_radii)
+    angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)
+    angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
+    angles[:, 1::2] += np.pi/n_angles
+
+    x = np.append(0, (radii*np.cos(angles)).flatten())
+    y = np.append(0, (radii*np.sin(angles)).flatten())
+    z = np.sin(-x*y)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)
+
+
+@mpl3d_image_comparison(['trisurf3d_shaded.png'], tol=0.03, style='mpl20')
+def test_trisurf3d_shaded():
+    n_angles = 36
+    n_radii = 8
+    radii = np.linspace(0.125, 1.0, n_radii)
+    angles = np.linspace(0, 2*np.pi, n_angles, endpoint=False)
+    angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1)
+    angles[:, 1::2] += np.pi/n_angles
+
+    x = np.append(0, (radii*np.cos(angles)).flatten())
+    y = np.append(0, (radii*np.sin(angles)).flatten())
+    z = np.sin(-x*y)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.plot_trisurf(x, y, z, color=[1, 0.5, 0], linewidth=0.2)
+
+
+@mpl3d_image_comparison(['wireframe3d.png'], style='mpl20')
+def test_wireframe3d():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.plot_wireframe(X, Y, Z, rcount=13, ccount=13)
+
+
+@mpl3d_image_comparison(['wireframe3dzerocstride.png'], style='mpl20')
+def test_wireframe3dzerocstride():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.plot_wireframe(X, Y, Z, rcount=13, ccount=0)
+
+
+@mpl3d_image_comparison(['wireframe3dzerorstride.png'], style='mpl20')
+def test_wireframe3dzerorstride():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    ax.plot_wireframe(X, Y, Z, rstride=0, cstride=10)
+
+
+def test_wireframe3dzerostrideraises():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    with pytest.raises(ValueError):
+        ax.plot_wireframe(X, Y, Z, rstride=0, cstride=0)
+
+
+def test_mixedsamplesraises():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    X, Y, Z = axes3d.get_test_data(0.05)
+    with pytest.raises(ValueError):
+        ax.plot_wireframe(X, Y, Z, rstride=10, ccount=50)
+    with pytest.raises(ValueError):
+        ax.plot_surface(X, Y, Z, cstride=50, rcount=10)
+
+
+# remove tolerance when regenerating the test image
+@mpl3d_image_comparison(['quiver3d.png'], style='mpl20', tol=0.003)
+def test_quiver3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    pivots = ['tip', 'middle', 'tail']
+    colors = ['tab:blue', 'tab:orange', 'tab:green']
+    for i, (pivot, color) in enumerate(zip(pivots, colors)):
+        x, y, z = np.meshgrid([-0.5, 0.5], [-0.5, 0.5], [-0.5, 0.5])
+        u = -x
+        v = -y
+        w = -z
+        # Offset each set in z direction
+        z += 2 * i
+        ax.quiver(x, y, z, u, v, w, length=1, pivot=pivot, color=color)
+        ax.scatter(x, y, z, color=color)
+
+    ax.set_xlim(-3, 3)
+    ax.set_ylim(-3, 3)
+    ax.set_zlim(-1, 5)
+
+
+@check_figures_equal(extensions=["png"])
+def test_quiver3d_empty(fig_test, fig_ref):
+    fig_ref.add_subplot(projection='3d')
+    x = y = z = u = v = w = []
+    ax = fig_test.add_subplot(projection='3d')
+    ax.quiver(x, y, z, u, v, w, length=0.1, pivot='tip', normalize=True)
+
+
+@mpl3d_image_comparison(['quiver3d_masked.png'], style='mpl20')
+def test_quiver3d_masked():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    # Using mgrid here instead of ogrid because masked_where doesn't
+    # seem to like broadcasting very much...
+    x, y, z = np.mgrid[-1:0.8:10j, -1:0.8:10j, -1:0.6:3j]
+
+    u = np.sin(np.pi * x) * np.cos(np.pi * y) * np.cos(np.pi * z)
+    v = -np.cos(np.pi * x) * np.sin(np.pi * y) * np.cos(np.pi * z)
+    w = (2/3)**0.5 * np.cos(np.pi * x) * np.cos(np.pi * y) * np.sin(np.pi * z)
+    u = np.ma.masked_where((-0.4 < x) & (x < 0.1), u, copy=False)
+    v = np.ma.masked_where((0.1 < y) & (y < 0.7), v, copy=False)
+
+    ax.quiver(x, y, z, u, v, w, length=0.1, pivot='tip', normalize=True)
+
+
+@mpl3d_image_comparison(['quiver3d_colorcoded.png'], style='mpl20')
+def test_quiver3d_colorcoded():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    x = y = dx = dz = np.zeros(10)
+    z = dy = np.arange(10.)
+
+    color = plt.cm.Reds(dy/dy.max())
+    ax.quiver(x, y, z, dx, dy, dz, colors=color)
+    ax.set_ylim(0, 10)
+
+
+def test_patch_modification():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection="3d")
+    circle = Circle((0, 0))
+    ax.add_patch(circle)
+    art3d.patch_2d_to_3d(circle)
+    circle.set_facecolor((1.0, 0.0, 0.0, 1))
+
+    assert mcolors.same_color(circle.get_facecolor(), (1, 0, 0, 1))
+    fig.canvas.draw()
+    assert mcolors.same_color(circle.get_facecolor(), (1, 0, 0, 1))
+
+
+@check_figures_equal(extensions=['png'])
+def test_patch_collection_modification(fig_test, fig_ref):
+    # Test that modifying Patch3DCollection properties after creation works.
+    patch1 = Circle((0, 0), 0.05)
+    patch2 = Circle((0.1, 0.1), 0.03)
+    facecolors = np.array([[0., 0.5, 0., 1.], [0.5, 0., 0., 0.5]])
+    c = art3d.Patch3DCollection([patch1, patch2], linewidths=3)
+
+    ax_test = fig_test.add_subplot(projection='3d')
+    ax_test.add_collection3d(c)
+    c.set_edgecolor('C2')
+    c.set_facecolor(facecolors)
+    c.set_alpha(0.7)
+    assert c.get_depthshade()
+    c.set_depthshade(False)
+    assert not c.get_depthshade()
+
+    patch1 = Circle((0, 0), 0.05)
+    patch2 = Circle((0.1, 0.1), 0.03)
+    facecolors = np.array([[0., 0.5, 0., 1.], [0.5, 0., 0., 0.5]])
+    c = art3d.Patch3DCollection([patch1, patch2], linewidths=3,
+                                edgecolor='C2', facecolor=facecolors,
+                                alpha=0.7, depthshade=False)
+
+    ax_ref = fig_ref.add_subplot(projection='3d')
+    ax_ref.add_collection3d(c)
+
+
+def test_poly3dcollection_verts_validation():
+    poly = [[0, 0, 1], [0, 1, 1], [0, 1, 0], [0, 0, 0]]
+    with pytest.raises(ValueError, match=r'list of \(N, 3\) array-like'):
+        art3d.Poly3DCollection(poly)  # should be Poly3DCollection([poly])
+
+    poly = np.array(poly, dtype=float)
+    with pytest.raises(ValueError, match=r'list of \(N, 3\) array-like'):
+        art3d.Poly3DCollection(poly)  # should be Poly3DCollection([poly])
+
+
+@mpl3d_image_comparison(['poly3dcollection_closed.png'], style='mpl20')
+def test_poly3dcollection_closed():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    poly1 = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float)
+    poly2 = np.array([[0, 1, 1], [1, 1, 1], [1, 1, 0]], float)
+    c1 = art3d.Poly3DCollection([poly1], linewidths=3, edgecolor='k',
+                                facecolor=(0.5, 0.5, 1, 0.5), closed=True)
+    c2 = art3d.Poly3DCollection([poly2], linewidths=3, edgecolor='k',
+                                facecolor=(1, 0.5, 0.5, 0.5), closed=False)
+    ax.add_collection3d(c1, autolim=False)
+    ax.add_collection3d(c2, autolim=False)
+
+
+def test_poly_collection_2d_to_3d_empty():
+    poly = PolyCollection([])
+    art3d.poly_collection_2d_to_3d(poly)
+    assert isinstance(poly, art3d.Poly3DCollection)
+    assert poly.get_paths() == []
+
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    ax.add_artist(poly)
+    minz = poly.do_3d_projection()
+    assert np.isnan(minz)
+
+    # Ensure drawing actually works.
+    fig.canvas.draw()
+
+
+@mpl3d_image_comparison(['poly3dcollection_alpha.png'], style='mpl20')
+def test_poly3dcollection_alpha():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    poly1 = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float)
+    poly2 = np.array([[0, 1, 1], [1, 1, 1], [1, 1, 0]], float)
+    c1 = art3d.Poly3DCollection([poly1], linewidths=3, edgecolor='k',
+                                facecolor=(0.5, 0.5, 1), closed=True)
+    c1.set_alpha(0.5)
+    c2 = art3d.Poly3DCollection([poly2], linewidths=3, closed=False)
+    # Post-creation modification should work.
+    c2.set_facecolor((1, 0.5, 0.5))
+    c2.set_edgecolor('k')
+    c2.set_alpha(0.5)
+    ax.add_collection3d(c1, autolim=False)
+    ax.add_collection3d(c2, autolim=False)
+
+
+@mpl3d_image_comparison(['add_collection3d_zs_array.png'], style='mpl20')
+def test_add_collection3d_zs_array():
+    theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
+    z = np.linspace(-2, 2, 100)
+    r = z**2 + 1
+    x = r * np.sin(theta)
+    y = r * np.cos(theta)
+
+    points = np.column_stack([x, y, z]).reshape(-1, 1, 3)
+    segments = np.concatenate([points[:-1], points[1:]], axis=1)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    norm = plt.Normalize(0, 2*np.pi)
+    # 2D LineCollection from x & y values
+    lc = LineCollection(segments[:, :, :2], cmap='twilight', norm=norm)
+    lc.set_array(np.mod(theta, 2*np.pi))
+    # Add 2D collection at z values to ax
+    line = ax.add_collection3d(lc, zs=segments[:, :, 2])
+
+    assert line is not None
+
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_xlim(-5, 5)
+    ax.set_ylim(-4, 6)
+    ax.set_zlim(-2, 2)
+
+
+@mpl3d_image_comparison(['add_collection3d_zs_scalar.png'], style='mpl20')
+def test_add_collection3d_zs_scalar():
+    theta = np.linspace(0, 2 * np.pi, 100)
+    z = 1
+    r = z**2 + 1
+    x = r * np.sin(theta)
+    y = r * np.cos(theta)
+
+    points = np.column_stack([x, y]).reshape(-1, 1, 2)
+    segments = np.concatenate([points[:-1], points[1:]], axis=1)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    norm = plt.Normalize(0, 2*np.pi)
+    lc = LineCollection(segments, cmap='twilight', norm=norm)
+    lc.set_array(theta)
+    line = ax.add_collection3d(lc, zs=z)
+
+    assert line is not None
+
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_xlim(-5, 5)
+    ax.set_ylim(-4, 6)
+    ax.set_zlim(0, 2)
+
+
+def test_line3dCollection_autoscaling():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    lines = [[(0, 0, 0), (1, 4, 2)],
+             [(1, 1, 3), (2, 0, 2)],
+             [(1, 0, 4), (1, 4, 5)]]
+
+    lc = art3d.Line3DCollection(lines)
+    ax.add_collection3d(lc)
+    assert np.allclose(ax.get_xlim3d(), (-0.041666666666666664, 2.0416666666666665))
+    assert np.allclose(ax.get_ylim3d(), (-0.08333333333333333, 4.083333333333333))
+    assert np.allclose(ax.get_zlim3d(), (-0.10416666666666666, 5.104166666666667))
+
+
+def test_poly3dCollection_autoscaling():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    poly = np.array([[0, 0, 0], [1, 1, 3], [1, 0, 4]])
+    col = art3d.Poly3DCollection([poly])
+    ax.add_collection3d(col)
+    assert np.allclose(ax.get_xlim3d(), (-0.020833333333333332, 1.0208333333333333))
+    assert np.allclose(ax.get_ylim3d(), (-0.020833333333333332, 1.0208333333333333))
+    assert np.allclose(ax.get_zlim3d(), (-0.0833333333333333, 4.083333333333333))
+
+
+@mpl3d_image_comparison(['axes3d_labelpad.png'],
+                        remove_text=False, style='mpl20')
+def test_axes3d_labelpad():
+    fig = plt.figure()
+    ax = fig.add_axes(Axes3D(fig))
+    # labelpad respects rcParams
+    assert ax.xaxis.labelpad == mpl.rcParams['axes.labelpad']
+    # labelpad can be set in set_label
+    ax.set_xlabel('X LABEL', labelpad=10)
+    assert ax.xaxis.labelpad == 10
+    ax.set_ylabel('Y LABEL')
+    ax.set_zlabel('Z LABEL', labelpad=20)
+    assert ax.zaxis.labelpad == 20
+    assert ax.get_zlabel() == 'Z LABEL'
+    # or manually
+    ax.yaxis.labelpad = 20
+    ax.zaxis.labelpad = -40
+
+    # Tick labels also respect tick.pad (also from rcParams)
+    for i, tick in enumerate(ax.yaxis.get_major_ticks()):
+        tick.set_pad(tick.get_pad() + 5 - i * 5)
+
+
+@mpl3d_image_comparison(['axes3d_cla.png'], remove_text=False, style='mpl20')
+def test_axes3d_cla():
+    # fixed in pull request 4553
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1, projection='3d')
+    ax.set_axis_off()
+    ax.cla()  # make sure the axis displayed is 3D (not 2D)
+
+
+@mpl3d_image_comparison(['axes3d_rotated.png'],
+                        remove_text=False, style='mpl20')
+def test_axes3d_rotated():
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1, projection='3d')
+    ax.view_init(90, 45, 0)  # look down, rotated. Should be square
+
+
+def test_plotsurface_1d_raises():
+    x = np.linspace(0.5, 10, num=100)
+    y = np.linspace(0.5, 10, num=100)
+    X, Y = np.meshgrid(x, y)
+    z = np.random.randn(100)
+
+    fig = plt.figure(figsize=(14, 6))
+    ax = fig.add_subplot(1, 2, 1, projection='3d')
+    with pytest.raises(ValueError):
+        ax.plot_surface(X, Y, z)
+
+
+def _test_proj_make_M():
+    # eye point
+    E = np.array([1000, -1000, 2000])
+    R = np.array([100, 100, 100])
+    V = np.array([0, 0, 1])
+    roll = 0
+    u, v, w = proj3d._view_axes(E, R, V, roll)
+    viewM = proj3d._view_transformation_uvw(u, v, w, E)
+    perspM = proj3d._persp_transformation(100, -100, 1)
+    M = np.dot(perspM, viewM)
+    return M
+
+
+def test_proj_transform():
+    M = _test_proj_make_M()
+    invM = np.linalg.inv(M)
+
+    xs = np.array([0, 1, 1, 0, 0, 0, 1, 1, 0, 0]) * 300.0
+    ys = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 0]) * 300.0
+    zs = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) * 300.0
+
+    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
+    ixs, iys, izs = proj3d.inv_transform(txs, tys, tzs, invM)
+
+    np.testing.assert_almost_equal(ixs, xs)
+    np.testing.assert_almost_equal(iys, ys)
+    np.testing.assert_almost_equal(izs, zs)
+
+
+def _test_proj_draw_axes(M, s=1, *args, **kwargs):
+    xs = [0, s, 0, 0]
+    ys = [0, 0, s, 0]
+    zs = [0, 0, 0, s]
+    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
+    o, ax, ay, az = zip(txs, tys)
+    lines = [(o, ax), (o, ay), (o, az)]
+
+    fig, ax = plt.subplots(*args, **kwargs)
+    linec = LineCollection(lines)
+    ax.add_collection(linec)
+    for x, y, t in zip(txs, tys, ['o', 'x', 'y', 'z']):
+        ax.text(x, y, t)
+
+    return fig, ax
+
+
+@mpl3d_image_comparison(['proj3d_axes_cube.png'], style='mpl20')
+def test_proj_axes_cube():
+    M = _test_proj_make_M()
+
+    ts = '0 1 2 3 0 4 5 6 7 4'.split()
+    xs = np.array([0, 1, 1, 0, 0, 0, 1, 1, 0, 0]) * 300.0
+    ys = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 0]) * 300.0
+    zs = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) * 300.0
+
+    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
+
+    fig, ax = _test_proj_draw_axes(M, s=400)
+
+    ax.scatter(txs, tys, c=tzs)
+    ax.plot(txs, tys, c='r')
+    for x, y, t in zip(txs, tys, ts):
+        ax.text(x, y, t)
+
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_xlim(-0.2, 0.2)
+    ax.set_ylim(-0.2, 0.2)
+
+
+@mpl3d_image_comparison(['proj3d_axes_cube_ortho.png'], style='mpl20')
+def test_proj_axes_cube_ortho():
+    E = np.array([200, 100, 100])
+    R = np.array([0, 0, 0])
+    V = np.array([0, 0, 1])
+    roll = 0
+    u, v, w = proj3d._view_axes(E, R, V, roll)
+    viewM = proj3d._view_transformation_uvw(u, v, w, E)
+    orthoM = proj3d._ortho_transformation(-1, 1)
+    M = np.dot(orthoM, viewM)
+
+    ts = '0 1 2 3 0 4 5 6 7 4'.split()
+    xs = np.array([0, 1, 1, 0, 0, 0, 1, 1, 0, 0]) * 100
+    ys = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 0]) * 100
+    zs = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) * 100
+
+    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
+
+    fig, ax = _test_proj_draw_axes(M, s=150)
+
+    ax.scatter(txs, tys, s=300-tzs)
+    ax.plot(txs, tys, c='r')
+    for x, y, t in zip(txs, tys, ts):
+        ax.text(x, y, t)
+
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    ax.set_xlim(-200, 200)
+    ax.set_ylim(-200, 200)
+
+
+def test_world():
+    xmin, xmax = 100, 120
+    ymin, ymax = -100, 100
+    zmin, zmax = 0.1, 0.2
+    M = proj3d.world_transformation(xmin, xmax, ymin, ymax, zmin, zmax)
+    np.testing.assert_allclose(M,
+                               [[5e-2, 0, 0, -5],
+                                [0, 5e-3, 0, 5e-1],
+                                [0, 0, 1e1, -1],
+                                [0, 0, 0, 1]])
+
+
+def test_autoscale():
+    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    assert ax.get_zscale() == 'linear'
+    ax._view_margin = 0
+    ax.margins(x=0, y=.1, z=.2)
+    ax.plot([0, 1], [0, 1], [0, 1])
+    assert ax.get_w_lims() == (0, 1, -.1, 1.1, -.2, 1.2)
+    ax.autoscale(False)
+    ax.set_autoscalez_on(True)
+    ax.plot([0, 2], [0, 2], [0, 2])
+    assert ax.get_w_lims() == (0, 1, -.1, 1.1, -.4, 2.4)
+    ax.autoscale(axis='x')
+    ax.plot([0, 2], [0, 2], [0, 2])
+    assert ax.get_w_lims() == (0, 2, -.1, 1.1, -.4, 2.4)
+
+
+@pytest.mark.parametrize('axis', ('x', 'y', 'z'))
+@pytest.mark.parametrize('auto', (True, False, None))
+def test_unautoscale(axis, auto):
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    x = np.arange(100)
+    y = np.linspace(-0.1, 0.1, 100)
+    ax.scatter(x, y)
+
+    get_autoscale_on = getattr(ax, f'get_autoscale{axis}_on')
+    set_lim = getattr(ax, f'set_{axis}lim')
+    get_lim = getattr(ax, f'get_{axis}lim')
+
+    post_auto = get_autoscale_on() if auto is None else auto
+
+    set_lim((-0.5, 0.5), auto=auto)
+    assert post_auto == get_autoscale_on()
+    fig.canvas.draw()
+    np.testing.assert_array_equal(get_lim(), (-0.5, 0.5))
+
+
+def test_axes3d_focal_length_checks():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    with pytest.raises(ValueError):
+        ax.set_proj_type('persp', focal_length=0)
+    with pytest.raises(ValueError):
+        ax.set_proj_type('ortho', focal_length=1)
+
+
+@mpl3d_image_comparison(['axes3d_focal_length.png'],
+                        remove_text=False, style='mpl20')
+def test_axes3d_focal_length():
+    fig, axs = plt.subplots(1, 2, subplot_kw={'projection': '3d'})
+    axs[0].set_proj_type('persp', focal_length=np.inf)
+    axs[1].set_proj_type('persp', focal_length=0.15)
+
+
+@mpl3d_image_comparison(['axes3d_ortho.png'], remove_text=False, style='mpl20')
+def test_axes3d_ortho():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_proj_type('ortho')
+
+
+@mpl3d_image_comparison(['axes3d_isometric.png'], style='mpl20')
+def test_axes3d_isometric():
+    from itertools import combinations, product
+    fig, ax = plt.subplots(subplot_kw=dict(
+        projection='3d',
+        proj_type='ortho',
+        box_aspect=(4, 4, 4)
+    ))
+    r = (-1, 1)  # stackoverflow.com/a/11156353
+    for s, e in combinations(np.array(list(product(r, r, r))), 2):
+        if abs(s - e).sum() == r[1] - r[0]:
+            ax.plot3D(*zip(s, e), c='k')
+    ax.view_init(elev=np.degrees(np.arctan(1. / np.sqrt(2))), azim=-45, roll=0)
+    ax.grid(True)
+
+
+@pytest.mark.parametrize('value', [np.inf, np.nan])
+@pytest.mark.parametrize(('setter', 'side'), [
+    ('set_xlim3d', 'left'),
+    ('set_xlim3d', 'right'),
+    ('set_ylim3d', 'bottom'),
+    ('set_ylim3d', 'top'),
+    ('set_zlim3d', 'bottom'),
+    ('set_zlim3d', 'top'),
+])
+def test_invalid_axes_limits(setter, side, value):
+    limit = {side: value}
+    fig = plt.figure()
+    obj = fig.add_subplot(projection='3d')
+    with pytest.raises(ValueError):
+        getattr(obj, setter)(**limit)
+
+
+class TestVoxels:
+    @mpl3d_image_comparison(['voxels-simple.png'], style='mpl20')
+    def test_simple(self):
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        x, y, z = np.indices((5, 4, 3))
+        voxels = (x == y) | (y == z)
+        ax.voxels(voxels)
+
+    @mpl3d_image_comparison(['voxels-edge-style.png'], style='mpl20')
+    def test_edge_style(self):
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        x, y, z = np.indices((5, 5, 4))
+        voxels = ((x - 2)**2 + (y - 2)**2 + (z-1.5)**2) < 2.2**2
+        v = ax.voxels(voxels, linewidths=3, edgecolor='C1')
+
+        # change the edge color of one voxel
+        v[max(v.keys())].set_edgecolor('C2')
+
+    @mpl3d_image_comparison(['voxels-named-colors.png'], style='mpl20')
+    def test_named_colors(self):
+        """Test with colors set to a 3D object array of strings."""
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        x, y, z = np.indices((10, 10, 10))
+        voxels = (x == y) | (y == z)
+        voxels = voxels & ~(x * y * z < 1)
+        colors = np.full((10, 10, 10), 'C0', dtype=np.object_)
+        colors[(x < 5) & (y < 5)] = '0.25'
+        colors[(x + z) < 10] = 'cyan'
+        ax.voxels(voxels, facecolors=colors)
+
+    @mpl3d_image_comparison(['voxels-rgb-data.png'], style='mpl20')
+    def test_rgb_data(self):
+        """Test with colors set to a 4d float array of rgb data."""
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        x, y, z = np.indices((10, 10, 10))
+        voxels = (x == y) | (y == z)
+        colors = np.zeros((10, 10, 10, 3))
+        colors[..., 0] = x / 9
+        colors[..., 1] = y / 9
+        colors[..., 2] = z / 9
+        ax.voxels(voxels, facecolors=colors)
+
+    @mpl3d_image_comparison(['voxels-alpha.png'], style='mpl20')
+    def test_alpha(self):
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        x, y, z = np.indices((10, 10, 10))
+        v1 = x == y
+        v2 = np.abs(x - y) < 2
+        voxels = v1 | v2
+        colors = np.zeros((10, 10, 10, 4))
+        colors[v2] = [1, 0, 0, 0.5]
+        colors[v1] = [0, 1, 0, 0.5]
+        v = ax.voxels(voxels, facecolors=colors)
+
+        assert type(v) is dict
+        for coord, poly in v.items():
+            assert voxels[coord], "faces returned for absent voxel"
+            assert isinstance(poly, art3d.Poly3DCollection)
+
+    @mpl3d_image_comparison(['voxels-xyz.png'],
+                            tol=0.01, remove_text=False, style='mpl20')
+    def test_xyz(self):
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        def midpoints(x):
+            sl = ()
+            for i in range(x.ndim):
+                x = (x[sl + np.index_exp[:-1]] +
+                     x[sl + np.index_exp[1:]]) / 2.0
+                sl += np.index_exp[:]
+            return x
+
+        # prepare some coordinates, and attach rgb values to each
+        r, g, b = np.indices((17, 17, 17)) / 16.0
+        rc = midpoints(r)
+        gc = midpoints(g)
+        bc = midpoints(b)
+
+        # define a sphere about [0.5, 0.5, 0.5]
+        sphere = (rc - 0.5)**2 + (gc - 0.5)**2 + (bc - 0.5)**2 < 0.5**2
+
+        # combine the color components
+        colors = np.zeros(sphere.shape + (3,))
+        colors[..., 0] = rc
+        colors[..., 1] = gc
+        colors[..., 2] = bc
+
+        # and plot everything
+        ax.voxels(r, g, b, sphere,
+                  facecolors=colors,
+                  edgecolors=np.clip(2*colors - 0.5, 0, 1),  # brighter
+                  linewidth=0.5)
+
+    def test_calling_conventions(self):
+        x, y, z = np.indices((3, 4, 5))
+        filled = np.ones((2, 3, 4))
+
+        fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+
+        # all the valid calling conventions
+        for kw in (dict(), dict(edgecolor='k')):
+            ax.voxels(filled, **kw)
+            ax.voxels(filled=filled, **kw)
+            ax.voxels(x, y, z, filled, **kw)
+            ax.voxels(x, y, z, filled=filled, **kw)
+
+        # duplicate argument
+        with pytest.raises(TypeError, match='voxels'):
+            ax.voxels(x, y, z, filled, filled=filled)
+        # missing arguments
+        with pytest.raises(TypeError, match='voxels'):
+            ax.voxels(x, y)
+        # x, y, z are positional only - this passes them on as attributes of
+        # Poly3DCollection
+        with pytest.raises(AttributeError):
+            ax.voxels(filled=filled, x=x, y=y, z=z)
+
+
+def test_line3d_set_get_data_3d():
+    x, y, z = [0, 1], [2, 3], [4, 5]
+    x2, y2, z2 = [6, 7], [8, 9], [10, 11]
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    lines = ax.plot(x, y, z)
+    line = lines[0]
+    np.testing.assert_array_equal((x, y, z), line.get_data_3d())
+    line.set_data_3d(x2, y2, z2)
+    np.testing.assert_array_equal((x2, y2, z2), line.get_data_3d())
+    line.set_xdata(x)
+    line.set_ydata(y)
+    line.set_3d_properties(zs=z, zdir='z')
+    np.testing.assert_array_equal((x, y, z), line.get_data_3d())
+    line.set_3d_properties(zs=0, zdir='z')
+    np.testing.assert_array_equal((x, y, np.zeros_like(z)), line.get_data_3d())
+
+
+@check_figures_equal(extensions=["png"])
+def test_inverted(fig_test, fig_ref):
+    # Plot then invert.
+    ax = fig_test.add_subplot(projection="3d")
+    ax.plot([1, 1, 10, 10], [1, 10, 10, 10], [1, 1, 1, 10])
+    ax.invert_yaxis()
+    # Invert then plot.
+    ax = fig_ref.add_subplot(projection="3d")
+    ax.invert_yaxis()
+    ax.plot([1, 1, 10, 10], [1, 10, 10, 10], [1, 1, 1, 10])
+
+
+def test_inverted_cla():
+    # GitHub PR #5450. Setting autoscale should reset
+    # axes to be non-inverted.
+    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    # 1. test that a new axis is not inverted per default
+    assert not ax.xaxis_inverted()
+    assert not ax.yaxis_inverted()
+    assert not ax.zaxis_inverted()
+    ax.set_xlim(1, 0)
+    ax.set_ylim(1, 0)
+    ax.set_zlim(1, 0)
+    assert ax.xaxis_inverted()
+    assert ax.yaxis_inverted()
+    assert ax.zaxis_inverted()
+    ax.cla()
+    assert not ax.xaxis_inverted()
+    assert not ax.yaxis_inverted()
+    assert not ax.zaxis_inverted()
+
+
+def test_ax3d_tickcolour():
+    fig = plt.figure()
+    ax = Axes3D(fig)
+
+    ax.tick_params(axis='x', colors='red')
+    ax.tick_params(axis='y', colors='red')
+    ax.tick_params(axis='z', colors='red')
+    fig.canvas.draw()
+
+    for tick in ax.xaxis.get_major_ticks():
+        assert tick.tick1line._color == 'red'
+    for tick in ax.yaxis.get_major_ticks():
+        assert tick.tick1line._color == 'red'
+    for tick in ax.zaxis.get_major_ticks():
+        assert tick.tick1line._color == 'red'
+
+
+@check_figures_equal(extensions=["png"])
+def test_ticklabel_format(fig_test, fig_ref):
+    axs = fig_test.subplots(4, 5, subplot_kw={"projection": "3d"})
+    for ax in axs.flat:
+        ax.set_xlim(1e7, 1e7 + 10)
+    for row, name in zip(axs, ["x", "y", "z", "both"]):
+        row[0].ticklabel_format(
+            axis=name, style="plain")
+        row[1].ticklabel_format(
+            axis=name, scilimits=(-2, 2))
+        row[2].ticklabel_format(
+            axis=name, useOffset=not mpl.rcParams["axes.formatter.useoffset"])
+        row[3].ticklabel_format(
+            axis=name, useLocale=not mpl.rcParams["axes.formatter.use_locale"])
+        row[4].ticklabel_format(
+            axis=name,
+            useMathText=not mpl.rcParams["axes.formatter.use_mathtext"])
+
+    def get_formatters(ax, names):
+        return [getattr(ax, name).get_major_formatter() for name in names]
+
+    axs = fig_ref.subplots(4, 5, subplot_kw={"projection": "3d"})
+    for ax in axs.flat:
+        ax.set_xlim(1e7, 1e7 + 10)
+    for row, names in zip(
+            axs, [["xaxis"], ["yaxis"], ["zaxis"], ["xaxis", "yaxis", "zaxis"]]
+    ):
+        for fmt in get_formatters(row[0], names):
+            fmt.set_scientific(False)
+        for fmt in get_formatters(row[1], names):
+            fmt.set_powerlimits((-2, 2))
+        for fmt in get_formatters(row[2], names):
+            fmt.set_useOffset(not mpl.rcParams["axes.formatter.useoffset"])
+        for fmt in get_formatters(row[3], names):
+            fmt.set_useLocale(not mpl.rcParams["axes.formatter.use_locale"])
+        for fmt in get_formatters(row[4], names):
+            fmt.set_useMathText(
+                not mpl.rcParams["axes.formatter.use_mathtext"])
+
+
+@check_figures_equal(extensions=["png"])
+def test_quiver3D_smoke(fig_test, fig_ref):
+    pivot = "middle"
+    # Make the grid
+    x, y, z = np.meshgrid(
+        np.arange(-0.8, 1, 0.2),
+        np.arange(-0.8, 1, 0.2),
+        np.arange(-0.8, 1, 0.8)
+    )
+    u = v = w = np.ones_like(x)
+
+    for fig, length in zip((fig_ref, fig_test), (1, 1.0)):
+        ax = fig.add_subplot(projection="3d")
+        ax.quiver(x, y, z, u, v, w, length=length, pivot=pivot)
+
+
+@image_comparison(["minor_ticks.png"], style="mpl20")
+def test_minor_ticks():
+    ax = plt.figure().add_subplot(projection="3d")
+    ax.set_xticks([0.25], minor=True)
+    ax.set_xticklabels(["quarter"], minor=True)
+    ax.set_yticks([0.33], minor=True)
+    ax.set_yticklabels(["third"], minor=True)
+    ax.set_zticks([0.50], minor=True)
+    ax.set_zticklabels(["half"], minor=True)
+
+
+# remove tolerance when regenerating the test image
+@mpl3d_image_comparison(['errorbar3d_errorevery.png'], style='mpl20', tol=0.003)
+def test_errorbar3d_errorevery():
+    """Tests errorevery functionality for 3D errorbars."""
+    t = np.arange(0, 2*np.pi+.1, 0.01)
+    x, y, z = np.sin(t), np.cos(3*t), np.sin(5*t)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    estep = 15
+    i = np.arange(t.size)
+    zuplims = (i % estep == 0) & (i // estep % 3 == 0)
+    zlolims = (i % estep == 0) & (i // estep % 3 == 2)
+
+    ax.errorbar(x, y, z, 0.2, zuplims=zuplims, zlolims=zlolims,
+                errorevery=estep)
+
+
+@mpl3d_image_comparison(['errorbar3d.png'], style='mpl20',
+                        tol=0.02 if platform.machine() == 'arm64' else 0)
+def test_errorbar3d():
+    """Tests limits, color styling, and legend for 3D errorbars."""
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    d = [1, 2, 3, 4, 5]
+    e = [.5, .5, .5, .5, .5]
+    ax.errorbar(x=d, y=d, z=d, xerr=e, yerr=e, zerr=e, capsize=3,
+                zuplims=[False, True, False, True, True],
+                zlolims=[True, False, False, True, False],
+                yuplims=True,
+                ecolor='purple', label='Error lines')
+    ax.legend()
+
+
+@image_comparison(['stem3d.png'], style='mpl20', tol=0.008)
+def test_stem3d():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig, axs = plt.subplots(2, 3, figsize=(8, 6),
+                            constrained_layout=True,
+                            subplot_kw={'projection': '3d'})
+
+    theta = np.linspace(0, 2*np.pi)
+    x = np.cos(theta - np.pi/2)
+    y = np.sin(theta - np.pi/2)
+    z = theta
+
+    for ax, zdir in zip(axs[0], ['x', 'y', 'z']):
+        ax.stem(x, y, z, orientation=zdir)
+        ax.set_title(f'orientation={zdir}')
+
+    x = np.linspace(-np.pi/2, np.pi/2, 20)
+    y = np.ones_like(x)
+    z = np.cos(x)
+
+    for ax, zdir in zip(axs[1], ['x', 'y', 'z']):
+        markerline, stemlines, baseline = ax.stem(
+            x, y, z,
+            linefmt='C4-.', markerfmt='C1D', basefmt='C2',
+            orientation=zdir)
+        ax.set_title(f'orientation={zdir}')
+        markerline.set(markerfacecolor='none', markeredgewidth=2)
+        baseline.set_linewidth(3)
+
+
+@image_comparison(["equal_box_aspect.png"], style="mpl20")
+def test_equal_box_aspect():
+    from itertools import product, combinations
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection="3d")
+
+    # Make data
+    u = np.linspace(0, 2 * np.pi, 100)
+    v = np.linspace(0, np.pi, 100)
+    x = np.outer(np.cos(u), np.sin(v))
+    y = np.outer(np.sin(u), np.sin(v))
+    z = np.outer(np.ones_like(u), np.cos(v))
+
+    # Plot the surface
+    ax.plot_surface(x, y, z)
+
+    # draw cube
+    r = [-1, 1]
+    for s, e in combinations(np.array(list(product(r, r, r))), 2):
+        if np.sum(np.abs(s - e)) == r[1] - r[0]:
+            ax.plot3D(*zip(s, e), color="b")
+
+    # Make axes limits
+    xyzlim = np.column_stack(
+        [ax.get_xlim3d(), ax.get_ylim3d(), ax.get_zlim3d()]
+    )
+    XYZlim = [min(xyzlim[0]), max(xyzlim[1])]
+    ax.set_xlim3d(XYZlim)
+    ax.set_ylim3d(XYZlim)
+    ax.set_zlim3d(XYZlim)
+    ax.axis('off')
+    ax.set_box_aspect((1, 1, 1))
+
+    with pytest.raises(ValueError, match="Argument zoom ="):
+        ax.set_box_aspect((1, 1, 1), zoom=-1)
+
+
+def test_colorbar_pos():
+    num_plots = 2
+    fig, axs = plt.subplots(1, num_plots, figsize=(4, 5),
+                            constrained_layout=True,
+                            subplot_kw={'projection': '3d'})
+    for ax in axs:
+        p_tri = ax.plot_trisurf(np.random.randn(5), np.random.randn(5),
+                                np.random.randn(5))
+
+    cbar = plt.colorbar(p_tri, ax=axs, orientation='horizontal')
+
+    fig.canvas.draw()
+    # check that actually on the bottom
+    assert cbar.ax.get_position().extents[1] < 0.2
+
+
+def test_inverted_zaxis():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.set_zlim(0, 1)
+    assert not ax.zaxis_inverted()
+    assert ax.get_zlim() == (0, 1)
+    assert ax.get_zbound() == (0, 1)
+
+    # Change bound
+    ax.set_zbound((0, 2))
+    assert not ax.zaxis_inverted()
+    assert ax.get_zlim() == (0, 2)
+    assert ax.get_zbound() == (0, 2)
+
+    # Change invert
+    ax.invert_zaxis()
+    assert ax.zaxis_inverted()
+    assert ax.get_zlim() == (2, 0)
+    assert ax.get_zbound() == (0, 2)
+
+    # Set upper bound
+    ax.set_zbound(upper=1)
+    assert ax.zaxis_inverted()
+    assert ax.get_zlim() == (1, 0)
+    assert ax.get_zbound() == (0, 1)
+
+    # Set lower bound
+    ax.set_zbound(lower=2)
+    assert ax.zaxis_inverted()
+    assert ax.get_zlim() == (2, 1)
+    assert ax.get_zbound() == (1, 2)
+
+
+def test_set_zlim():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    assert np.allclose(ax.get_zlim(), (-1/48, 49/48))
+    ax.set_zlim(zmax=2)
+    assert np.allclose(ax.get_zlim(), (-1/48, 2))
+    ax.set_zlim(zmin=1)
+    assert ax.get_zlim() == (1, 2)
+
+    with pytest.raises(
+            TypeError, match="Cannot pass both 'lower' and 'min'"):
+        ax.set_zlim(bottom=0, zmin=1)
+    with pytest.raises(
+            TypeError, match="Cannot pass both 'upper' and 'max'"):
+        ax.set_zlim(top=0, zmax=1)
+
+
+@check_figures_equal(extensions=["png"])
+def test_shared_view(fig_test, fig_ref):
+    elev, azim, roll = 5, 20, 30
+    ax1 = fig_test.add_subplot(131, projection="3d")
+    ax2 = fig_test.add_subplot(132, projection="3d", shareview=ax1)
+    ax3 = fig_test.add_subplot(133, projection="3d")
+    ax3.shareview(ax1)
+    ax2.view_init(elev=elev, azim=azim, roll=roll, share=True)
+
+    for subplot_num in (131, 132, 133):
+        ax = fig_ref.add_subplot(subplot_num, projection="3d")
+        ax.view_init(elev=elev, azim=azim, roll=roll)
+
+
+def test_shared_axes_retick():
+    fig = plt.figure()
+    ax1 = fig.add_subplot(211, projection="3d")
+    ax2 = fig.add_subplot(212, projection="3d", sharez=ax1)
+    ax1.plot([0, 1], [0, 1], [0, 2])
+    ax2.plot([0, 1], [0, 1], [0, 2])
+    ax1.set_zticks([-0.5, 0, 2, 2.5])
+    # check that setting ticks on a shared axis is synchronized
+    assert ax1.get_zlim() == (-0.5, 2.5)
+    assert ax2.get_zlim() == (-0.5, 2.5)
+
+
+def test_rotate():
+    """Test rotating using the left mouse button."""
+    for roll in [0, 30]:
+        fig = plt.figure()
+        ax = fig.add_subplot(1, 1, 1, projection='3d')
+        ax.view_init(0, 0, roll)
+        ax.figure.canvas.draw()
+
+        # drag mouse horizontally to change azimuth
+        dx = 0.1
+        dy = 0.2
+        ax._button_press(
+            mock_event(ax, button=MouseButton.LEFT, xdata=0, ydata=0))
+        ax._on_move(
+            mock_event(ax, button=MouseButton.LEFT,
+                           xdata=dx*ax._pseudo_w, ydata=dy*ax._pseudo_h))
+        ax.figure.canvas.draw()
+        roll_radians = np.deg2rad(ax.roll)
+        cs = np.cos(roll_radians)
+        sn = np.sin(roll_radians)
+        assert ax.elev == (-dy*180*cs + dx*180*sn)
+        assert ax.azim == (-dy*180*sn - dx*180*cs)
+        assert ax.roll == roll
+
+
+def test_pan():
+    """Test mouse panning using the middle mouse button."""
+
+    def convert_lim(dmin, dmax):
+        """Convert min/max limits to center and range."""
+        center = (dmin + dmax) / 2
+        range_ = dmax - dmin
+        return center, range_
+
+    ax = plt.figure().add_subplot(projection='3d')
+    ax.scatter(0, 0, 0)
+    ax.figure.canvas.draw()
+
+    x_center0, x_range0 = convert_lim(*ax.get_xlim3d())
+    y_center0, y_range0 = convert_lim(*ax.get_ylim3d())
+    z_center0, z_range0 = convert_lim(*ax.get_zlim3d())
+
+    # move mouse diagonally to pan along all axis.
+    ax._button_press(
+        mock_event(ax, button=MouseButton.MIDDLE, xdata=0, ydata=0))
+    ax._on_move(
+        mock_event(ax, button=MouseButton.MIDDLE, xdata=1, ydata=1))
+
+    x_center, x_range = convert_lim(*ax.get_xlim3d())
+    y_center, y_range = convert_lim(*ax.get_ylim3d())
+    z_center, z_range = convert_lim(*ax.get_zlim3d())
+
+    # Ranges have not changed
+    assert x_range == pytest.approx(x_range0)
+    assert y_range == pytest.approx(y_range0)
+    assert z_range == pytest.approx(z_range0)
+
+    # But center positions have
+    assert x_center != pytest.approx(x_center0)
+    assert y_center != pytest.approx(y_center0)
+    assert z_center != pytest.approx(z_center0)
+
+
+@pytest.mark.parametrize("tool,button,key,expected",
+                         [("zoom", MouseButton.LEFT, None,  # zoom in
+                          ((0.00, 0.06), (0.01, 0.07), (0.02, 0.08))),
+                          ("zoom", MouseButton.LEFT, 'x',  # zoom in
+                          ((-0.01, 0.10), (-0.03, 0.08), (-0.06, 0.06))),
+                          ("zoom", MouseButton.LEFT, 'y',  # zoom in
+                          ((-0.07, 0.05), (-0.04, 0.08), (0.00, 0.12))),
+                          ("zoom", MouseButton.RIGHT, None,  # zoom out
+                          ((-0.09, 0.15), (-0.08, 0.17), (-0.07, 0.18))),
+                          ("pan", MouseButton.LEFT, None,
+                          ((-0.70, -0.58), (-1.04, -0.91), (-1.27, -1.15))),
+                          ("pan", MouseButton.LEFT, 'x',
+                          ((-0.97, -0.84), (-0.58, -0.46), (-0.06, 0.06))),
+                          ("pan", MouseButton.LEFT, 'y',
+                          ((0.20, 0.32), (-0.51, -0.39), (-1.27, -1.15)))])
+def test_toolbar_zoom_pan(tool, button, key, expected):
+    # NOTE: The expected zoom values are rough ballparks of moving in the view
+    #       to make sure we are getting the right direction of motion.
+    #       The specific values can and should change if the zoom movement
+    #       scaling factor gets updated.
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.scatter(0, 0, 0)
+    fig.canvas.draw()
+    xlim0, ylim0, zlim0 = ax.get_xlim3d(), ax.get_ylim3d(), ax.get_zlim3d()
+
+    # Mouse from (0, 0) to (1, 1)
+    d0 = (0, 0)
+    d1 = (1, 1)
+    # Convert to screen coordinates ("s").  Events are defined only with pixel
+    # precision, so round the pixel values, and below, check against the
+    # corresponding xdata/ydata, which are close but not equal to d0/d1.
+    s0 = ax.transData.transform(d0).astype(int)
+    s1 = ax.transData.transform(d1).astype(int)
+
+    # Set up the mouse movements
+    start_event = MouseEvent(
+        "button_press_event", fig.canvas, *s0, button, key=key)
+    stop_event = MouseEvent(
+        "button_release_event", fig.canvas, *s1, button, key=key)
+
+    tb = NavigationToolbar2(fig.canvas)
+    if tool == "zoom":
+        tb.zoom()
+        tb.press_zoom(start_event)
+        tb.drag_zoom(stop_event)
+        tb.release_zoom(stop_event)
+    else:
+        tb.pan()
+        tb.press_pan(start_event)
+        tb.drag_pan(stop_event)
+        tb.release_pan(stop_event)
+
+    # Should be close, but won't be exact due to screen integer resolution
+    xlim, ylim, zlim = expected
+    assert ax.get_xlim3d() == pytest.approx(xlim, abs=0.01)
+    assert ax.get_ylim3d() == pytest.approx(ylim, abs=0.01)
+    assert ax.get_zlim3d() == pytest.approx(zlim, abs=0.01)
+
+    # Ensure that back, forward, and home buttons work
+    tb.back()
+    assert ax.get_xlim3d() == pytest.approx(xlim0)
+    assert ax.get_ylim3d() == pytest.approx(ylim0)
+    assert ax.get_zlim3d() == pytest.approx(zlim0)
+
+    tb.forward()
+    assert ax.get_xlim3d() == pytest.approx(xlim, abs=0.01)
+    assert ax.get_ylim3d() == pytest.approx(ylim, abs=0.01)
+    assert ax.get_zlim3d() == pytest.approx(zlim, abs=0.01)
+
+    tb.home()
+    assert ax.get_xlim3d() == pytest.approx(xlim0)
+    assert ax.get_ylim3d() == pytest.approx(ylim0)
+    assert ax.get_zlim3d() == pytest.approx(zlim0)
+
+
+@mpl.style.context('default')
+@check_figures_equal(extensions=["png"])
+def test_scalarmap_update(fig_test, fig_ref):
+
+    x, y, z = np.array(list(itertools.product(*[np.arange(0, 5, 1),
+                                                np.arange(0, 5, 1),
+                                                np.arange(0, 5, 1)]))).T
+    c = x + y
+
+    # test
+    ax_test = fig_test.add_subplot(111, projection='3d')
+    sc_test = ax_test.scatter(x, y, z, c=c, s=40, cmap='viridis')
+    # force a draw
+    fig_test.canvas.draw()
+    # mark it as "stale"
+    sc_test.changed()
+
+    # ref
+    ax_ref = fig_ref.add_subplot(111, projection='3d')
+    sc_ref = ax_ref.scatter(x, y, z, c=c, s=40, cmap='viridis')
+
+
+def test_subfigure_simple():
+    # smoketest that subfigures can work...
+    fig = plt.figure()
+    sf = fig.subfigures(1, 2)
+    ax = sf[0].add_subplot(1, 1, 1, projection='3d')
+    ax = sf[1].add_subplot(1, 1, 1, projection='3d', label='other')
+
+
+# Update style when regenerating the test image
+@image_comparison(baseline_images=['computed_zorder'], remove_text=True,
+                  extensions=['png'], style=('mpl20'))
+def test_computed_zorder():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax1 = fig.add_subplot(221, projection='3d')
+    ax2 = fig.add_subplot(222, projection='3d')
+    ax2.computed_zorder = False
+
+    # create a horizontal plane
+    corners = ((0, 0, 0), (0, 5, 0), (5, 5, 0), (5, 0, 0))
+    for ax in (ax1, ax2):
+        tri = art3d.Poly3DCollection([corners],
+                                     facecolors='white',
+                                     edgecolors='black',
+                                     zorder=1)
+        ax.add_collection3d(tri)
+
+        # plot a vector
+        ax.plot((2, 2), (2, 2), (0, 4), c='red', zorder=2)
+
+        # plot some points
+        ax.scatter((3, 3), (1, 3), (1, 3), c='red', zorder=10)
+
+        ax.set_xlim((0, 5.0))
+        ax.set_ylim((0, 5.0))
+        ax.set_zlim((0, 2.5))
+
+    ax3 = fig.add_subplot(223, projection='3d')
+    ax4 = fig.add_subplot(224, projection='3d')
+    ax4.computed_zorder = False
+
+    dim = 10
+    X, Y = np.meshgrid((-dim, dim), (-dim, dim))
+    Z = np.zeros((2, 2))
+
+    angle = 0.5
+    X2, Y2 = np.meshgrid((-dim, dim), (0, dim))
+    Z2 = Y2 * angle
+    X3, Y3 = np.meshgrid((-dim, dim), (-dim, 0))
+    Z3 = Y3 * angle
+
+    r = 7
+    M = 1000
+    th = np.linspace(0, 2 * np.pi, M)
+    x, y, z = r * np.cos(th),  r * np.sin(th), angle * r * np.sin(th)
+    for ax in (ax3, ax4):
+        ax.plot_surface(X2, Y3, Z3,
+                        color='blue',
+                        alpha=0.5,
+                        linewidth=0,
+                        zorder=-1)
+        ax.plot(x[y < 0], y[y < 0], z[y < 0],
+                lw=5,
+                linestyle='--',
+                color='green',
+                zorder=0)
+
+        ax.plot_surface(X, Y, Z,
+                        color='red',
+                        alpha=0.5,
+                        linewidth=0,
+                        zorder=1)
+
+        ax.plot(r * np.sin(th), r * np.cos(th), np.zeros(M),
+                lw=5,
+                linestyle='--',
+                color='black',
+                zorder=2)
+
+        ax.plot_surface(X2, Y2, Z2,
+                        color='blue',
+                        alpha=0.5,
+                        linewidth=0,
+                        zorder=3)
+
+        ax.plot(x[y > 0], y[y > 0], z[y > 0], lw=5,
+                linestyle='--',
+                color='green',
+                zorder=4)
+        ax.view_init(elev=20, azim=-20, roll=0)
+        ax.axis('off')
+
+
+def test_format_coord():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    x = np.arange(10)
+    ax.plot(x, np.sin(x))
+    xv = 0.1
+    yv = 0.1
+    fig.canvas.draw()
+    assert ax.format_coord(xv, yv) == 'x=10.5227, y pane=1.0417, z=0.1444'
+
+    # Modify parameters
+    ax.view_init(roll=30, vertical_axis="y")
+    fig.canvas.draw()
+    assert ax.format_coord(xv, yv) == 'x pane=9.1875, y=0.9761, z=0.1291'
+
+    # Reset parameters
+    ax.view_init()
+    fig.canvas.draw()
+    assert ax.format_coord(xv, yv) == 'x=10.5227, y pane=1.0417, z=0.1444'
+
+    # Check orthographic projection
+    ax.set_proj_type('ortho')
+    fig.canvas.draw()
+    assert ax.format_coord(xv, yv) == 'x=10.8869, y pane=1.0417, z=0.1528'
+
+    # Check non-default perspective projection
+    ax.set_proj_type('persp', focal_length=0.1)
+    fig.canvas.draw()
+    assert ax.format_coord(xv, yv) == 'x=9.0620, y pane=1.0417, z=0.1110'
+
+
+def test_get_axis_position():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    x = np.arange(10)
+    ax.plot(x, np.sin(x))
+    fig.canvas.draw()
+    assert ax.get_axis_position() == (False, True, False)
+
+
+def test_margins():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.margins(0.2)
+    assert ax.margins() == (0.2, 0.2, 0.2)
+    ax.margins(0.1, 0.2, 0.3)
+    assert ax.margins() == (0.1, 0.2, 0.3)
+    ax.margins(x=0)
+    assert ax.margins() == (0, 0.2, 0.3)
+    ax.margins(y=0.1)
+    assert ax.margins() == (0, 0.1, 0.3)
+    ax.margins(z=0)
+    assert ax.margins() == (0, 0.1, 0)
+
+
+def test_margin_getters():
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.margins(0.1, 0.2, 0.3)
+    assert ax.get_xmargin() == 0.1
+    assert ax.get_ymargin() == 0.2
+    assert ax.get_zmargin() == 0.3
+
+
+@pytest.mark.parametrize('err, args, kwargs, match', (
+        (ValueError, (-1,), {}, r'margin must be greater than -0\.5'),
+        (ValueError, (1, -1, 1), {}, r'margin must be greater than -0\.5'),
+        (ValueError, (1, 1, -1), {}, r'margin must be greater than -0\.5'),
+        (ValueError, tuple(), {'x': -1}, r'margin must be greater than -0\.5'),
+        (ValueError, tuple(), {'y': -1}, r'margin must be greater than -0\.5'),
+        (ValueError, tuple(), {'z': -1}, r'margin must be greater than -0\.5'),
+        (TypeError, (1, ), {'x': 1},
+         'Cannot pass both positional and keyword'),
+        (TypeError, (1, ), {'x': 1, 'y': 1, 'z': 1},
+         'Cannot pass both positional and keyword'),
+        (TypeError, (1, ), {'x': 1, 'y': 1},
+         'Cannot pass both positional and keyword'),
+        (TypeError, (1, 1), {}, 'Must pass a single positional argument for'),
+))
+def test_margins_errors(err, args, kwargs, match):
+    with pytest.raises(err, match=match):
+        fig = plt.figure()
+        ax = fig.add_subplot(projection='3d')
+        ax.margins(*args, **kwargs)
+
+
+@check_figures_equal(extensions=["png"])
+def test_text_3d(fig_test, fig_ref):
+    ax = fig_ref.add_subplot(projection="3d")
+    txt = Text(0.5, 0.5, r'Foo bar $\int$')
+    art3d.text_2d_to_3d(txt, z=1)
+    ax.add_artist(txt)
+    assert txt.get_position_3d() == (0.5, 0.5, 1)
+
+    ax = fig_test.add_subplot(projection="3d")
+    t3d = art3d.Text3D(0.5, 0.5, 1, r'Foo bar $\int$')
+    ax.add_artist(t3d)
+    assert t3d.get_position_3d() == (0.5, 0.5, 1)
+
+
+def test_draw_single_lines_from_Nx1():
+    # Smoke test for GH#23459
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    ax.plot([[0], [1]], [[0], [1]], [[0], [1]])
+
+
+@check_figures_equal(extensions=["png"])
+def test_pathpatch_3d(fig_test, fig_ref):
+    ax = fig_ref.add_subplot(projection="3d")
+    path = Path.unit_rectangle()
+    patch = PathPatch(path)
+    art3d.pathpatch_2d_to_3d(patch, z=(0, 0.5, 0.7, 1, 0), zdir='y')
+    ax.add_artist(patch)
+
+    ax = fig_test.add_subplot(projection="3d")
+    pp3d = art3d.PathPatch3D(path, zs=(0, 0.5, 0.7, 1, 0), zdir='y')
+    ax.add_artist(pp3d)
+
+
+@image_comparison(baseline_images=['scatter_spiral.png'],
+                  remove_text=True,
+                  style='mpl20')
+def test_scatter_spiral():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    th = np.linspace(0, 2 * np.pi * 6, 256)
+    sc = ax.scatter(np.sin(th), np.cos(th), th, s=(1 + th * 5), c=th ** 2)
+
+    # force at least 1 draw!
+    fig.canvas.draw()
+
+
+def test_Poly3DCollection_get_path():
+    # Smoke test to see that get_path does not raise
+    # See GH#27361
+    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    p = Circle((0, 0), 1.0)
+    ax.add_patch(p)
+    art3d.pathpatch_2d_to_3d(p)
+    p.get_path()
+
+
+def test_Poly3DCollection_get_facecolor():
+    # Smoke test to see that get_facecolor does not raise
+    # See GH#4067
+    y, x = np.ogrid[1:10:100j, 1:10:100j]
+    z2 = np.cos(x) ** 3 - np.sin(y) ** 2
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    r = ax.plot_surface(x, y, z2, cmap='hot')
+    r.get_facecolor()
+
+
+def test_Poly3DCollection_get_edgecolor():
+    # Smoke test to see that get_edgecolor does not raise
+    # See GH#4067
+    y, x = np.ogrid[1:10:100j, 1:10:100j]
+    z2 = np.cos(x) ** 3 - np.sin(y) ** 2
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    r = ax.plot_surface(x, y, z2, cmap='hot')
+    r.get_edgecolor()
+
+
+@pytest.mark.parametrize(
+    "vertical_axis, proj_expected, axis_lines_expected, tickdirs_expected",
+    [
+        (
+            "z",
+            [
+                [0.0, 1.142857, 0.0, -0.571429],
+                [0.0, 0.0, 0.857143, -0.428571],
+                [0.0, 0.0, 0.0, -10.0],
+                [-1.142857, 0.0, 0.0, 10.571429],
+            ],
+            [
+                ([0.05617978, 0.06329114], [-0.04213483, -0.04746835]),
+                ([-0.06329114, 0.06329114], [-0.04746835, -0.04746835]),
+                ([-0.06329114, -0.06329114], [-0.04746835, 0.04746835]),
+            ],
+            [1, 0, 0],
+        ),
+        (
+            "y",
+            [
+                [1.142857, 0.0, 0.0, -0.571429],
+                [0.0, 0.857143, 0.0, -0.428571],
+                [0.0, 0.0, 0.0, -10.0],
+                [0.0, 0.0, -1.142857, 10.571429],
+            ],
+            [
+                ([-0.06329114, 0.06329114], [0.04746835, 0.04746835]),
+                ([0.06329114, 0.06329114], [-0.04746835, 0.04746835]),
+                ([-0.05617978, -0.06329114], [0.04213483, 0.04746835]),
+            ],
+            [2, 2, 0],
+        ),
+        (
+            "x",
+            [
+                [0.0, 0.0, 1.142857, -0.571429],
+                [0.857143, 0.0, 0.0, -0.428571],
+                [0.0, 0.0, 0.0, -10.0],
+                [0.0, -1.142857, 0.0, 10.571429],
+            ],
+            [
+                ([-0.06329114, -0.06329114], [0.04746835, -0.04746835]),
+                ([0.06329114, 0.05617978], [0.04746835, 0.04213483]),
+                ([0.06329114, -0.06329114], [0.04746835, 0.04746835]),
+            ],
+            [1, 2, 1],
+        ),
+    ],
+)
+def test_view_init_vertical_axis(
+    vertical_axis, proj_expected, axis_lines_expected, tickdirs_expected
+):
+    """
+    Test the actual projection, axis lines and ticks matches expected values.
+
+    Parameters
+    ----------
+    vertical_axis : str
+        Axis to align vertically.
+    proj_expected : ndarray
+        Expected values from ax.get_proj().
+    axis_lines_expected : tuple of arrays
+        Edgepoints of the axis line. Expected values retrieved according
+        to ``ax.get_[xyz]axis().line.get_data()``.
+    tickdirs_expected : list of int
+        indexes indicating which axis to create a tick line along.
+    """
+    rtol = 2e-06
+    ax = plt.subplot(1, 1, 1, projection="3d")
+    ax.view_init(elev=0, azim=0, roll=0, vertical_axis=vertical_axis)
+    ax.figure.canvas.draw()
+
+    # Assert the projection matrix:
+    proj_actual = ax.get_proj()
+    np.testing.assert_allclose(proj_expected, proj_actual, rtol=rtol)
+
+    for i, axis in enumerate([ax.get_xaxis(), ax.get_yaxis(), ax.get_zaxis()]):
+        # Assert black lines are correctly aligned:
+        axis_line_expected = axis_lines_expected[i]
+        axis_line_actual = axis.line.get_data()
+        np.testing.assert_allclose(axis_line_expected, axis_line_actual,
+                                   rtol=rtol)
+
+        # Assert ticks are correctly aligned:
+        tickdir_expected = tickdirs_expected[i]
+        tickdir_actual = axis._get_tickdir('default')
+        np.testing.assert_array_equal(tickdir_expected, tickdir_actual)
+
+
+@pytest.mark.parametrize("vertical_axis", ["x", "y", "z"])
+def test_on_move_vertical_axis(vertical_axis: str) -> None:
+    """
+    Test vertical axis is respected when rotating the plot interactively.
+    """
+    ax = plt.subplot(1, 1, 1, projection="3d")
+    ax.view_init(elev=0, azim=0, roll=0, vertical_axis=vertical_axis)
+    ax.figure.canvas.draw()
+
+    proj_before = ax.get_proj()
+    event_click = mock_event(ax, button=MouseButton.LEFT, xdata=0, ydata=1)
+    ax._button_press(event_click)
+
+    event_move = mock_event(ax, button=MouseButton.LEFT, xdata=0.5, ydata=0.8)
+    ax._on_move(event_move)
+
+    assert ax._axis_names.index(vertical_axis) == ax._vertical_axis
+
+    # Make sure plot has actually moved:
+    proj_after = ax.get_proj()
+    np.testing.assert_raises(
+        AssertionError, np.testing.assert_allclose, proj_before, proj_after
+    )
+
+
+@pytest.mark.parametrize(
+    "vertical_axis, aspect_expected",
+    [
+        ("x", [1.190476, 0.892857, 1.190476]),
+        ("y", [0.892857, 1.190476, 1.190476]),
+        ("z", [1.190476, 1.190476, 0.892857]),
+    ],
+)
+def test_set_box_aspect_vertical_axis(vertical_axis, aspect_expected):
+    ax = plt.subplot(1, 1, 1, projection="3d")
+    ax.view_init(elev=0, azim=0, roll=0, vertical_axis=vertical_axis)
+    ax.figure.canvas.draw()
+
+    ax.set_box_aspect(None)
+
+    np.testing.assert_allclose(aspect_expected, ax._box_aspect, rtol=1e-6)
+
+
+@image_comparison(baseline_images=['arc_pathpatch.png'],
+                  remove_text=True,
+                  style='mpl20')
+def test_arc_pathpatch():
+    ax = plt.subplot(1, 1, 1, projection="3d")
+    a = mpatch.Arc((0.5, 0.5), width=0.5, height=0.9,
+                   angle=20, theta1=10, theta2=130)
+    ax.add_patch(a)
+    art3d.pathpatch_2d_to_3d(a, z=0, zdir='z')
+
+
+@image_comparison(baseline_images=['panecolor_rcparams.png'],
+                  remove_text=True,
+                  style='mpl20')
+def test_panecolor_rcparams():
+    with plt.rc_context({'axes3d.xaxis.panecolor': 'r',
+                         'axes3d.yaxis.panecolor': 'g',
+                         'axes3d.zaxis.panecolor': 'b'}):
+        fig = plt.figure(figsize=(1, 1))
+        fig.add_subplot(projection='3d')
+
+
+@check_figures_equal(extensions=["png"])
+def test_mutating_input_arrays_y_and_z(fig_test, fig_ref):
+    """
+    Test to see if the `z` axis does not get mutated
+    after a call to `Axes3D.plot`
+
+    test cases came from GH#8990
+    """
+    ax1 = fig_test.add_subplot(111, projection='3d')
+    x = [1, 2, 3]
+    y = [0.0, 0.0, 0.0]
+    z = [0.0, 0.0, 0.0]
+    ax1.plot(x, y, z, 'o-')
+
+    # mutate y,z to get a nontrivial line
+    y[:] = [1, 2, 3]
+    z[:] = [1, 2, 3]
+
+    # draw the same plot without mutating x and y
+    ax2 = fig_ref.add_subplot(111, projection='3d')
+    x = [1, 2, 3]
+    y = [0.0, 0.0, 0.0]
+    z = [0.0, 0.0, 0.0]
+    ax2.plot(x, y, z, 'o-')
+
+
+def test_scatter_masked_color():
+    """
+    Test color parameter usage with non-finite coordinate arrays.
+
+    GH#26236
+    """
+
+    x = [np.nan, 1, 2,  1]
+    y = [0, np.inf, 2,  1]
+    z = [0, 1, -np.inf, 1]
+    colors = [
+        [0.0, 0.0, 0.0, 1],
+        [0.0, 0.0, 0.0, 1],
+        [0.0, 0.0, 0.0, 1],
+        [0.0, 0.0, 0.0, 1]
+    ]
+
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+    path3d = ax.scatter(x, y, z, color=colors)
+
+    # Assert sizes' equality
+    assert len(path3d.get_offsets()) ==\
+           len(super(type(path3d), path3d).get_facecolors())
+
+
+@mpl3d_image_comparison(['surface3d_zsort_inf.png'], style='mpl20')
+def test_surface3d_zsort_inf():
+    plt.rcParams['axes3d.automargin'] = True  # Remove when image is regenerated
+    fig = plt.figure()
+    ax = fig.add_subplot(projection='3d')
+
+    x, y = np.mgrid[-2:2:0.1, -2:2:0.1]
+    z = np.sin(x)**2 + np.cos(y)**2
+    z[x.shape[0] // 2:, x.shape[1] // 2:] = np.inf
+
+    ax.plot_surface(x, y, z, cmap='jet')
+    ax.view_init(elev=45, azim=145)
+
+
+def test_Poly3DCollection_init_value_error():
+    # smoke test to ensure the input check works
+    # GH#26420
+    with pytest.raises(ValueError,
+                       match='You must provide facecolors, edgecolors, '
+                        'or both for shade to work.'):
+        poly = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float)
+        c = art3d.Poly3DCollection([poly], shade=True)
+
+
+def test_ndarray_color_kwargs_value_error():
+    # smoke test
+    # ensures ndarray can be passed to color in kwargs for 3d projection plot
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.scatter(1, 0, 0, color=np.array([0, 0, 0, 1]))
+    fig.canvas.draw()
diff --git a/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_legend3d.py b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_legend3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..0935bbe7f6b0788d968f57e06beb3c35d2fc51d9
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/mpl_toolkits/mplot3d/tests/test_legend3d.py
@@ -0,0 +1,117 @@
+import platform
+
+import numpy as np
+
+import matplotlib as mpl
+from matplotlib.colors import same_color
+from matplotlib.testing.decorators import image_comparison
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import art3d
+
+
+@image_comparison(['legend_plot.png'], remove_text=True, style='mpl20')
+def test_legend_plot():
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    x = np.arange(10)
+    ax.plot(x, 5 - x, 'o', zdir='y', label='z=1')
+    ax.plot(x, x - 5, 'o', zdir='y', label='z=-1')
+    ax.legend()
+
+
+@image_comparison(['legend_bar.png'], remove_text=True, style='mpl20')
+def test_legend_bar():
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    x = np.arange(10)
+    b1 = ax.bar(x, x, zdir='y', align='edge', color='m')
+    b2 = ax.bar(x, x[::-1], zdir='x', align='edge', color='g')
+    ax.legend([b1[0], b2[0]], ['up', 'down'])
+
+
+@image_comparison(['fancy.png'], remove_text=True, style='mpl20',
+                  tol=0.011 if platform.machine() == 'arm64' else 0)
+def test_fancy():
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    ax.plot(np.arange(10), np.full(10, 5), np.full(10, 5), 'o--', label='line')
+    ax.scatter(np.arange(10), np.arange(10, 0, -1), label='scatter')
+    ax.errorbar(np.full(10, 5), np.arange(10), np.full(10, 10),
+                xerr=0.5, zerr=0.5, label='errorbar')
+    ax.legend(loc='lower left', ncols=2, title='My legend', numpoints=1)
+
+
+def test_linecollection_scaled_dashes():
+    lines1 = [[(0, .5), (.5, 1)], [(.3, .6), (.2, .2)]]
+    lines2 = [[[0.7, .2], [.8, .4]], [[.5, .7], [.6, .1]]]
+    lines3 = [[[0.6, .2], [.8, .4]], [[.5, .7], [.1, .1]]]
+    lc1 = art3d.Line3DCollection(lines1, linestyles="--", lw=3)
+    lc2 = art3d.Line3DCollection(lines2, linestyles="-.")
+    lc3 = art3d.Line3DCollection(lines3, linestyles=":", lw=.5)
+
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    ax.add_collection(lc1)
+    ax.add_collection(lc2)
+    ax.add_collection(lc3)
+
+    leg = ax.legend([lc1, lc2, lc3], ['line1', 'line2', 'line 3'])
+    h1, h2, h3 = leg.legend_handles
+
+    for oh, lh in zip((lc1, lc2, lc3), (h1, h2, h3)):
+        assert oh.get_linestyles()[0] == lh._dash_pattern
+
+
+def test_handlerline3d():
+    # Test marker consistency for monolithic Line3D legend handler.
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    ax.scatter([0, 1], [0, 1], marker="v")
+    handles = [art3d.Line3D([0], [0], [0], marker="v")]
+    leg = ax.legend(handles, ["Aardvark"], numpoints=1)
+    assert handles[0].get_marker() == leg.legend_handles[0].get_marker()
+
+
+def test_contour_legend_elements():
+    x, y = np.mgrid[1:10, 1:10]
+    h = x * y
+    colors = ['blue', '#00FF00', 'red']
+
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    cs = ax.contour(x, y, h, levels=[10, 30, 50], colors=colors, extend='both')
+
+    artists, labels = cs.legend_elements()
+    assert labels == ['$x = 10.0$', '$x = 30.0$', '$x = 50.0$']
+    assert all(isinstance(a, mpl.lines.Line2D) for a in artists)
+    assert all(same_color(a.get_color(), c)
+               for a, c in zip(artists, colors))
+
+
+def test_contourf_legend_elements():
+    x, y = np.mgrid[1:10, 1:10]
+    h = x * y
+
+    fig, ax = plt.subplots(subplot_kw=dict(projection='3d'))
+    cs = ax.contourf(x, y, h, levels=[10, 30, 50],
+                     colors=['#FFFF00', '#FF00FF', '#00FFFF'],
+                     extend='both')
+    cs.cmap.set_over('red')
+    cs.cmap.set_under('blue')
+    cs.changed()
+    artists, labels = cs.legend_elements()
+    assert labels == ['$x \\leq -1e+250s$',
+                      '$10.0 < x \\leq 30.0$',
+                      '$30.0 < x \\leq 50.0$',
+                      '$x > 1e+250s$']
+    expected_colors = ('blue', '#FFFF00', '#FF00FF', 'red')
+    assert all(isinstance(a, mpl.patches.Rectangle) for a in artists)
+    assert all(same_color(a.get_facecolor(), c)
+               for a, c in zip(artists, expected_colors))
+
+
+def test_legend_Poly3dCollection():
+
+    verts = np.asarray([[0, 0, 0], [0, 1, 1], [1, 0, 1]])
+    mesh = art3d.Poly3DCollection([verts], label="surface")
+
+    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    mesh.set_edgecolor('k')
+    handle = ax.add_collection3d(mesh)
+    leg = ax.legend()
+    assert (leg.legend_handles[0].get_facecolor()
+            == handle.get_facecolor()).all()
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__init__.py b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ed615e33900ba1de279d78e055052694b495dcb
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__init__.py
@@ -0,0 +1,8 @@
+# This is the public API of tiktoken
+from .core import Encoding as Encoding
+from .model import encoding_for_model as encoding_for_model
+from .model import encoding_name_for_model as encoding_name_for_model
+from .registry import get_encoding as get_encoding
+from .registry import list_encoding_names as list_encoding_names
+
+__version__ = "0.8.0"
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/load.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/load.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aebf2caf7b1bdf49ef4bde47e0791ecf6e06f459
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/load.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/model.cpython-310.pyc b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/model.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab5769c0b361b90046c56e00a7344d53aa0e6e6d
Binary files /dev/null and b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/__pycache__/model.cpython-310.pyc differ
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/_educational.py b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/_educational.py
new file mode 100644
index 0000000000000000000000000000000000000000..317e77560c2b95c2c8a7b3d0d170b2af6de239c9
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/_educational.py
@@ -0,0 +1,223 @@
+"""This is an educational implementation of the byte pair encoding algorithm."""
+
+from __future__ import annotations
+
+import collections
+
+import regex
+
+import tiktoken
+
+
+class SimpleBytePairEncoding:
+    def __init__(self, *, pat_str: str, mergeable_ranks: dict[bytes, int]) -> None:
+        """Creates an Encoding object."""
+        # A regex pattern string that is used to split the input text
+        self.pat_str = pat_str
+        # A dictionary mapping token bytes to their ranks. The ranks correspond to merge priority
+        self.mergeable_ranks = mergeable_ranks
+
+        self._decoder = {token: token_bytes for token_bytes, token in mergeable_ranks.items()}
+        self._pat = regex.compile(pat_str)
+
+    def encode(self, text: str, visualise: str | None = "colour") -> list[int]:
+        """Encodes a string into tokens.
+
+        >>> enc.encode("hello world")
+        [388, 372]
+        """
+        # Use the regex to split the text into (approximately) words
+        words = self._pat.findall(text)
+        tokens = []
+        for word in words:
+            # Turn each word into tokens, using the byte pair encoding algorithm
+            word_bytes = word.encode("utf-8")
+            word_tokens = bpe_encode(self.mergeable_ranks, word_bytes, visualise=visualise)
+            tokens.extend(word_tokens)
+        return tokens
+
+    def decode_bytes(self, tokens: list[int]) -> bytes:
+        """Decodes a list of tokens into bytes.
+
+        >>> enc.decode_bytes([388, 372])
+        b'hello world'
+        """
+        return b"".join(self._decoder[token] for token in tokens)
+
+    def decode(self, tokens: list[int]) -> str:
+        """Decodes a list of tokens into a string.
+
+        Decoded bytes are not guaranteed to be valid UTF-8. In that case, we replace
+        the invalid bytes with the replacement character "�".
+
+        >>> enc.decode([388, 372])
+        'hello world'
+        """
+        return self.decode_bytes(tokens).decode("utf-8", errors="replace")
+
+    def decode_tokens_bytes(self, tokens: list[int]) -> list[bytes]:
+        """Decodes a list of tokens into a list of bytes.
+
+        Useful for visualising how a string is tokenised.
+
+        >>> enc.decode_tokens_bytes([388, 372])
+        [b'hello', b' world']
+        """
+        return [self._decoder[token] for token in tokens]
+
+    @staticmethod
+    def train(training_data: str, vocab_size: int, pat_str: str):
+        """Train a BPE tokeniser on some data!"""
+        mergeable_ranks = bpe_train(data=training_data, vocab_size=vocab_size, pat_str=pat_str)
+        return SimpleBytePairEncoding(pat_str=pat_str, mergeable_ranks=mergeable_ranks)
+
+    @staticmethod
+    def from_tiktoken(encoding):
+        if isinstance(encoding, str):
+            encoding = tiktoken.get_encoding(encoding)
+        return SimpleBytePairEncoding(
+            pat_str=encoding._pat_str, mergeable_ranks=encoding._mergeable_ranks
+        )
+
+
+def bpe_encode(
+    mergeable_ranks: dict[bytes, int], input: bytes, visualise: str | None = "colour"
+) -> list[int]:
+    parts = [bytes([b]) for b in input]
+    while True:
+        # See the intermediate merges play out!
+        if visualise:
+            if visualise in ["colour", "color"]:
+                visualise_tokens(parts)
+            elif visualise == "simple":
+                print(parts)
+
+        # Iterate over all pairs and find the pair we want to merge the most
+        min_idx = None
+        min_rank = None
+        for i, pair in enumerate(zip(parts[:-1], parts[1:])):
+            rank = mergeable_ranks.get(pair[0] + pair[1])
+            if rank is not None and (min_rank is None or rank < min_rank):
+                min_idx = i
+                min_rank = rank
+
+        # If there were no pairs we could merge, we're done!
+        if min_rank is None:
+            break
+        assert min_idx is not None
+
+        # Otherwise, merge that pair and leave the rest unchanged. Then repeat.
+        parts = parts[:min_idx] + [parts[min_idx] + parts[min_idx + 1]] + parts[min_idx + 2 :]
+
+    if visualise:
+        print()
+
+    tokens = [mergeable_ranks[part] for part in parts]
+    return tokens
+
+
+def bpe_train(
+    data: str, vocab_size: int, pat_str: str, visualise: str | None = "colour"
+) -> dict[bytes, int]:
+    # First, add tokens for each individual byte value
+    if vocab_size < 2**8:
+        raise ValueError("vocab_size must be at least 256, so we can encode all bytes")
+    ranks = {}
+    for i in range(2**8):
+        ranks[bytes([i])] = i
+
+    # Splinter up our data into lists of bytes
+    # data = "Hello world"
+    # words = [
+    #     [b'H', b'e', b'l', b'l', b'o'],
+    #     [b' ', b'w', b'o', b'r', b'l', b'd']
+    # ]
+    words: list[list[bytes]] = [
+        [bytes([b]) for b in word.encode("utf-8")] for word in regex.findall(pat_str, data)
+    ]
+
+    # Now, use our data to figure out which merges we should make
+    while len(ranks) < vocab_size:
+        # Find the most common pair. This will become our next token
+        stats = collections.Counter()
+        for piece in words:
+            for pair in zip(piece[:-1], piece[1:]):
+                stats[pair] += 1
+
+        most_common_pair = max(stats, key=lambda x: stats[x])
+        token_bytes = most_common_pair[0] + most_common_pair[1]
+        token = len(ranks)
+        # Add the new token!
+        ranks[token_bytes] = token
+
+        # Now merge that most common pair in all the words. That is, update our training data
+        # to reflect our decision to make that pair into a new token.
+        new_words = []
+        for word in words:
+            new_word = []
+            i = 0
+            while i < len(word) - 1:
+                if (word[i], word[i + 1]) == most_common_pair:
+                    # We found our pair! Merge it
+                    new_word.append(token_bytes)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            if i == len(word) - 1:
+                new_word.append(word[i])
+            new_words.append(new_word)
+        words = new_words
+
+        # See the intermediate merges play out!
+        if visualise:
+            print(f"The current most common pair is {most_common_pair[0]} + {most_common_pair[1]}")
+            print(f"So we made {token_bytes} our {len(ranks)}th token")
+            if visualise in ["colour", "color"]:
+                print("Now the first fifty words in our training data look like:")
+                visualise_tokens([token for word in words[:50] for token in word])
+            elif visualise == "simple":
+                print("Now the first twenty words in our training data look like:")
+                for word in words[:20]:
+                    print(word)
+            print("\n")
+
+    return ranks
+
+
+def visualise_tokens(token_values: list[bytes]) -> None:
+    background = [f"\u001b[48;5;{i}m" for i in [167, 179, 185, 77, 80, 68, 134]]
+    # If token boundaries do not occur at unicode character boundaries, it's unclear how best to
+    # visualise the token. Here, we'll just use the unicode replacement character to represent some
+    # fraction of a character.
+    unicode_token_values = [x.decode("utf-8", errors="replace") for x in token_values]
+
+    running_length = 0
+    last_color = None
+    for token in unicode_token_values:
+        color = background[running_length % len(background)]
+        if color == last_color:
+            color = background[(running_length + 1) % len(background)]
+            assert color != last_color
+        last_color = color
+        running_length += len(token)
+        print(color + token, end="")
+    print("\u001b[0m")
+
+
+def train_simple_encoding():
+    gpt2_pattern = (
+        r"""'s|'t|'re|'ve|'m|'ll|'d| ?[\p{L}]+| ?[\p{N}]+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
+    )
+    with open(__file__) as f:
+        data = f.read()
+
+    enc = SimpleBytePairEncoding.train(data, vocab_size=600, pat_str=gpt2_pattern)
+
+    print("This is the sequence of merges performed in order to encode 'hello world':")
+    tokens = enc.encode("hello world")
+    assert enc.decode(tokens) == "hello world"
+    assert enc.decode_bytes(tokens) == b"hello world"
+    assert enc.decode_tokens_bytes(tokens) == [b"hello", b" world"]
+
+    return enc
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/core.py b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dcdc327ef41e8dfceba7acc499656212607ba9c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/core.py
@@ -0,0 +1,405 @@
+from __future__ import annotations
+
+import functools
+from concurrent.futures import ThreadPoolExecutor
+from typing import AbstractSet, Collection, Literal, NoReturn, Sequence
+
+import regex
+
+from tiktoken import _tiktoken
+
+
+class Encoding:
+    def __init__(
+        self,
+        name: str,
+        *,
+        pat_str: str,
+        mergeable_ranks: dict[bytes, int],
+        special_tokens: dict[str, int],
+        explicit_n_vocab: int | None = None,
+    ):
+        """Creates an Encoding object.
+
+        See openai_public.py for examples of how to construct an Encoding object.
+
+        Args:
+            name: The name of the encoding. It should be clear from the name of the encoding
+                what behaviour to expect, in particular, encodings with different special tokens
+                should have different names.
+            pat_str: A regex pattern string that is used to split the input text.
+            mergeable_ranks: A dictionary mapping mergeable token bytes to their ranks. The ranks
+                must correspond to merge priority.
+            special_tokens: A dictionary mapping special token strings to their token values.
+            explicit_n_vocab: The number of tokens in the vocabulary. If provided, it is checked
+                that the number of mergeable tokens and special tokens is equal to this number.
+        """
+        self.name = name
+
+        self._pat_str = pat_str
+        self._mergeable_ranks = mergeable_ranks
+        self._special_tokens = special_tokens
+
+        self.max_token_value = max(
+            max(mergeable_ranks.values()), max(special_tokens.values(), default=0)
+        )
+        if explicit_n_vocab:
+            assert len(mergeable_ranks) + len(special_tokens) == explicit_n_vocab
+            assert self.max_token_value == explicit_n_vocab - 1
+
+        self._core_bpe = _tiktoken.CoreBPE(mergeable_ranks, special_tokens, pat_str)
+
+    def __repr__(self) -> str:
+        return f"<Encoding {self.name!r}>"
+
+    # ====================
+    # Encoding
+    # ====================
+
+    def encode_ordinary(self, text: str) -> list[int]:
+        """Encodes a string into tokens, ignoring special tokens.
+
+        This is equivalent to `encode(text, disallowed_special=())` (but slightly faster).
+
+        ```
+        >>> enc.encode_ordinary("hello world")
+        [31373, 995]
+        """
+        try:
+            return self._core_bpe.encode_ordinary(text)
+        except UnicodeEncodeError:
+            # See comment in encode
+            text = text.encode("utf-16", "surrogatepass").decode("utf-16", "replace")
+            return self._core_bpe.encode_ordinary(text)
+
+    def encode(
+        self,
+        text: str,
+        *,
+        allowed_special: Literal["all"] | AbstractSet[str] = set(),  # noqa: B006
+        disallowed_special: Literal["all"] | Collection[str] = "all",
+    ) -> list[int]:
+        """Encodes a string into tokens.
+
+        Special tokens are artificial tokens used to unlock capabilities from a model,
+        such as fill-in-the-middle. So we want to be careful about accidentally encoding special
+        tokens, since they can be used to trick a model into doing something we don't want it to do.
+
+        Hence, by default, encode will raise an error if it encounters text that corresponds
+        to a special token. This can be controlled on a per-token level using the `allowed_special`
+        and `disallowed_special` parameters. In particular:
+        - Setting `disallowed_special` to () will prevent this function from raising errors and
+          cause all text corresponding to special tokens to be encoded as natural text.
+        - Setting `allowed_special` to "all" will cause this function to treat all text
+          corresponding to special tokens to be encoded as special tokens.
+
+        ```
+        >>> enc.encode("hello world")
+        [31373, 995]
+        >>> enc.encode("<|endoftext|>", allowed_special={"<|endoftext|>"})
+        [50256]
+        >>> enc.encode("<|endoftext|>", allowed_special="all")
+        [50256]
+        >>> enc.encode("<|endoftext|>")
+        # Raises ValueError
+        >>> enc.encode("<|endoftext|>", disallowed_special=())
+        [27, 91, 437, 1659, 5239, 91, 29]
+        ```
+        """
+        if allowed_special == "all":
+            allowed_special = self.special_tokens_set
+        if disallowed_special == "all":
+            disallowed_special = self.special_tokens_set - allowed_special
+        if disallowed_special:
+            if not isinstance(disallowed_special, frozenset):
+                disallowed_special = frozenset(disallowed_special)
+            if match := _special_token_regex(disallowed_special).search(text):
+                raise_disallowed_special_token(match.group())
+
+        try:
+            return self._core_bpe.encode(text, allowed_special)
+        except UnicodeEncodeError:
+            # BPE operates on bytes, but the regex operates on unicode. If we pass a str that is
+            # invalid UTF-8 to Rust, it will rightfully complain. Here we do a quick and dirty
+            # fixup for any surrogate pairs that may have sneaked their way into the text.
+            # Technically, this introduces a place where encode + decode doesn't roundtrip a Python
+            # string, but given that this is input we want to support, maybe that's okay.
+            # Also we use errors="replace" to handle weird things like lone surrogates.
+            text = text.encode("utf-16", "surrogatepass").decode("utf-16", "replace")
+            return self._core_bpe.encode(text, allowed_special)
+
+    def encode_ordinary_batch(self, text: list[str], *, num_threads: int = 8) -> list[list[int]]:
+        """Encodes a list of strings into tokens, in parallel, ignoring special tokens.
+
+        This is equivalent to `encode_batch(text, disallowed_special=())` (but slightly faster).
+
+        ```
+        >>> enc.encode_ordinary_batch(["hello world", "goodbye world"])
+        [[31373, 995], [11274, 16390, 995]]
+        ```
+        """
+        encoder = functools.partial(self.encode_ordinary)
+        with ThreadPoolExecutor(num_threads) as e:
+            return list(e.map(encoder, text))
+
+    def encode_batch(
+        self,
+        text: list[str],
+        *,
+        num_threads: int = 8,
+        allowed_special: Literal["all"] | AbstractSet[str] = set(),  # noqa: B006
+        disallowed_special: Literal["all"] | Collection[str] = "all",
+    ) -> list[list[int]]:
+        """Encodes a list of strings into tokens, in parallel.
+
+        See `encode` for more details on `allowed_special` and `disallowed_special`.
+
+        ```
+        >>> enc.encode_batch(["hello world", "goodbye world"])
+        [[31373, 995], [11274, 16390, 995]]
+        ```
+        """
+        if allowed_special == "all":
+            allowed_special = self.special_tokens_set
+        if disallowed_special == "all":
+            disallowed_special = self.special_tokens_set - allowed_special
+        if not isinstance(disallowed_special, frozenset):
+            disallowed_special = frozenset(disallowed_special)
+
+        encoder = functools.partial(
+            self.encode, allowed_special=allowed_special, disallowed_special=disallowed_special
+        )
+        with ThreadPoolExecutor(num_threads) as e:
+            return list(e.map(encoder, text))
+
+    def encode_with_unstable(
+        self,
+        text: str,
+        *,
+        allowed_special: Literal["all"] | AbstractSet[str] = set(),  # noqa: B006
+        disallowed_special: Literal["all"] | Collection[str] = "all",
+    ) -> tuple[list[int], list[list[int]]]:
+        """Encodes a string into stable tokens and possible completion sequences.
+
+        Note that the stable tokens will only represent a substring of `text`.
+
+        See `encode` for more details on `allowed_special` and `disallowed_special`.
+
+        This API should itself be considered unstable.
+
+        ```
+        >>> enc.encode_with_unstable("hello fanta")
+        ([31373], [(277, 4910), (5113, 265), ..., (8842,)])
+
+        >>> text = "..."
+        >>> stable_tokens, completions = enc.encode_with_unstable(text)
+        >>> assert text.encode().startswith(enc.decode_bytes(stable_tokens))
+        >>> assert all(enc.decode_bytes(stable_tokens + seq).startswith(text.encode()) for seq in completions)
+        ```
+        """
+        if allowed_special == "all":
+            allowed_special = self.special_tokens_set
+        if disallowed_special == "all":
+            disallowed_special = self.special_tokens_set - allowed_special
+        if disallowed_special:
+            if not isinstance(disallowed_special, frozenset):
+                disallowed_special = frozenset(disallowed_special)
+            if match := _special_token_regex(disallowed_special).search(text):
+                raise_disallowed_special_token(match.group())
+
+        return self._core_bpe.encode_with_unstable(text, allowed_special)
+
+    def encode_single_token(self, text_or_bytes: str | bytes) -> int:
+        """Encodes text corresponding to a single token to its token value.
+
+        NOTE: this will encode all special tokens.
+
+        Raises `KeyError` if the token is not in the vocabulary.
+
+        ```
+        >>> enc.encode_single_token("hello")
+        31373
+        ```
+        """
+        if isinstance(text_or_bytes, str):
+            text_or_bytes = text_or_bytes.encode("utf-8")
+        return self._core_bpe.encode_single_token(text_or_bytes)
+
+    # ====================
+    # Decoding
+    # ====================
+
+    def decode_bytes(self, tokens: Sequence[int]) -> bytes:
+        """Decodes a list of tokens into bytes.
+
+        ```
+        >>> enc.decode_bytes([31373, 995])
+        b'hello world'
+        ```
+        """
+        return self._core_bpe.decode_bytes(tokens)
+
+    def decode(self, tokens: Sequence[int], errors: str = "replace") -> str:
+        """Decodes a list of tokens into a string.
+
+        WARNING: the default behaviour of this function is lossy, since decoded bytes are not
+        guaranteed to be valid UTF-8. You can control this behaviour using the `errors` parameter,
+        for instance, setting `errors=strict`.
+
+        ```
+        >>> enc.decode([31373, 995])
+        'hello world'
+        ```
+        """
+        return self._core_bpe.decode_bytes(tokens).decode("utf-8", errors=errors)
+
+    def decode_single_token_bytes(self, token: int) -> bytes:
+        """Decodes a token into bytes.
+
+        NOTE: this will decode all special tokens.
+
+        Raises `KeyError` if the token is not in the vocabulary.
+
+        ```
+        >>> enc.decode_single_token_bytes(31373)
+        b'hello'
+        ```
+        """
+        return self._core_bpe.decode_single_token_bytes(token)
+
+    def decode_tokens_bytes(self, tokens: Sequence[int]) -> list[bytes]:
+        """Decodes a list of tokens into a list of bytes.
+
+        Useful for visualising tokenisation.
+        >>> enc.decode_tokens_bytes([31373, 995])
+        [b'hello', b' world']
+        """
+        return [self.decode_single_token_bytes(token) for token in tokens]
+
+    def decode_with_offsets(self, tokens: Sequence[int]) -> tuple[str, list[int]]:
+        """Decodes a list of tokens into a string and a list of offsets.
+
+        Each offset is the index into text corresponding to the start of each token.
+        If UTF-8 character boundaries do not line up with token boundaries, the offset is the index
+        of the first character that contains bytes from the token.
+
+        This will currently raise if given tokens that decode to invalid UTF-8; this behaviour may
+        change in the future to be more permissive.
+
+        >>> enc.decode_with_offsets([31373, 995])
+        ('hello world', [0, 5])
+        """
+        token_bytes = self.decode_tokens_bytes(tokens)
+
+        text_len = 0
+        offsets = []
+        for token in token_bytes:
+            offsets.append(max(0, text_len - (0x80 <= token[0] < 0xC0)))
+            text_len += sum(1 for c in token if not 0x80 <= c < 0xC0)
+
+        # TODO: assess correctness for errors="ignore" and errors="replace"
+        text = b"".join(token_bytes).decode("utf-8", errors="strict")
+        return text, offsets
+
+    def decode_batch(
+        self, batch: Sequence[Sequence[int]], *, errors: str = "replace", num_threads: int = 8
+    ) -> list[str]:
+        """Decodes a batch (list of lists of tokens) into a list of strings."""
+        decoder = functools.partial(self.decode, errors=errors)
+        with ThreadPoolExecutor(num_threads) as e:
+            return list(e.map(decoder, batch))
+
+    def decode_bytes_batch(
+        self, batch: Sequence[Sequence[int]], *, num_threads: int = 8
+    ) -> list[bytes]:
+        """Decodes a batch (list of lists of tokens) into a list of bytes."""
+        with ThreadPoolExecutor(num_threads) as e:
+            return list(e.map(self.decode_bytes, batch))
+
+    # ====================
+    # Miscellaneous
+    # ====================
+
+    def token_byte_values(self) -> list[bytes]:
+        """Returns the list of all token byte values."""
+        return self._core_bpe.token_byte_values()
+
+    @property
+    def eot_token(self) -> int:
+        return self._special_tokens["<|endoftext|>"]
+
+    @functools.cached_property
+    def special_tokens_set(self) -> set[str]:
+        return set(self._special_tokens.keys())
+
+    @property
+    def n_vocab(self) -> int:
+        """For backwards compatibility. Prefer to use `enc.max_token_value + 1`."""
+        return self.max_token_value + 1
+
+    # ====================
+    # Private
+    # ====================
+
+    def _encode_single_piece(self, text_or_bytes: str | bytes) -> list[int]:
+        """Encodes text corresponding to bytes without a regex split.
+
+        NOTE: this will not encode any special tokens.
+
+        ```
+        >>> enc.encode_single_piece("helloqqqq")
+        [31373, 38227, 38227]
+        ```
+        """
+        if isinstance(text_or_bytes, str):
+            text_or_bytes = text_or_bytes.encode("utf-8")
+        return self._core_bpe.encode_single_piece(text_or_bytes)
+
+    def _encode_only_native_bpe(self, text: str) -> list[int]:
+        """Encodes a string into tokens, but do regex splitting in Python."""
+        _unused_pat = regex.compile(self._pat_str)
+        ret = []
+        for piece in regex.findall(_unused_pat, text):
+            ret.extend(self._core_bpe.encode_single_piece(piece))
+        return ret
+
+    def _encode_bytes(self, text: bytes) -> list[int]:
+        return self._core_bpe._encode_bytes(text)
+
+    def __getstate__(self) -> object:
+        import tiktoken.registry
+
+        # As an optimisation, pickle registered encodings by reference
+        if self is tiktoken.registry.ENCODINGS.get(self.name):
+            return self.name
+        return {
+            "name": self.name,
+            "pat_str": self._pat_str,
+            "mergeable_ranks": self._mergeable_ranks,
+            "special_tokens": self._special_tokens,
+        }
+
+    def __setstate__(self, value: object) -> None:
+        import tiktoken.registry
+
+        if isinstance(value, str):
+            self.__dict__ = tiktoken.registry.get_encoding(value).__dict__
+            return
+        self.__init__(**value)
+
+
+@functools.lru_cache(maxsize=128)
+def _special_token_regex(tokens: frozenset[str]) -> "regex.Pattern[str]":
+    inner = "|".join(regex.escape(token) for token in tokens)
+    return regex.compile(f"({inner})")
+
+
+def raise_disallowed_special_token(token: str) -> NoReturn:
+    raise ValueError(
+        f"Encountered text corresponding to disallowed special token {token!r}.\n"
+        "If you want this text to be encoded as a special token, "
+        f"pass it to `allowed_special`, e.g. `allowed_special={{{token!r}, ...}}`.\n"
+        f"If you want this text to be encoded as normal text, disable the check for this token "
+        f"by passing `disallowed_special=(enc.special_tokens_set - {{{token!r}}})`.\n"
+        "To disable this check for all special tokens, pass `disallowed_special=()`.\n"
+    )
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/py.typed b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/evalkit_internvl/lib/python3.10/site-packages/tiktoken/registry.py b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..17c4574f6063e922f83f9fb000c5e1784ac299fe
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/tiktoken/registry.py
@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import functools
+import importlib
+import pkgutil
+import threading
+from typing import Any, Callable, Sequence
+
+import tiktoken_ext
+
+import tiktoken
+from tiktoken.core import Encoding
+
+_lock = threading.RLock()
+ENCODINGS: dict[str, Encoding] = {}
+ENCODING_CONSTRUCTORS: dict[str, Callable[[], dict[str, Any]]] | None = None
+
+
+@functools.lru_cache
+def _available_plugin_modules() -> Sequence[str]:
+    # tiktoken_ext is a namespace package
+    # submodules inside tiktoken_ext will be inspected for ENCODING_CONSTRUCTORS attributes
+    # - we use namespace package pattern so `pkgutil.iter_modules` is fast
+    # - it's a separate top-level package because namespace subpackages of non-namespace
+    #   packages don't quite do what you want with editable installs
+    mods = []
+    plugin_mods = pkgutil.iter_modules(tiktoken_ext.__path__, tiktoken_ext.__name__ + ".")
+    for _, mod_name, _ in plugin_mods:
+        mods.append(mod_name)
+    return mods
+
+
+def _find_constructors() -> None:
+    global ENCODING_CONSTRUCTORS
+    with _lock:
+        if ENCODING_CONSTRUCTORS is not None:
+            return
+        ENCODING_CONSTRUCTORS = {}
+
+        try:
+            for mod_name in _available_plugin_modules():
+                mod = importlib.import_module(mod_name)
+                try:
+                    constructors = mod.ENCODING_CONSTRUCTORS
+                except AttributeError as e:
+                    raise ValueError(
+                        f"tiktoken plugin {mod_name} does not define ENCODING_CONSTRUCTORS"
+                    ) from e
+                for enc_name, constructor in constructors.items():
+                    if enc_name in ENCODING_CONSTRUCTORS:
+                        raise ValueError(
+                            f"Duplicate encoding name {enc_name} in tiktoken plugin {mod_name}"
+                        )
+                    ENCODING_CONSTRUCTORS[enc_name] = constructor
+        except Exception:
+            # Ensure we idempotently raise errors
+            ENCODING_CONSTRUCTORS = None
+            raise
+
+
+
+
+def get_encoding(encoding_name: str) -> Encoding:
+    if not isinstance(encoding_name, str):
+        raise ValueError(f"Expected a string in get_encoding, got {type(encoding_name)}")
+
+    if encoding_name in ENCODINGS:
+        return ENCODINGS[encoding_name]
+
+    with _lock:
+        if encoding_name in ENCODINGS:
+            return ENCODINGS[encoding_name]
+
+        if ENCODING_CONSTRUCTORS is None:
+            _find_constructors()
+            assert ENCODING_CONSTRUCTORS is not None
+
+        if encoding_name not in ENCODING_CONSTRUCTORS:
+            raise ValueError(
+                f"Unknown encoding {encoding_name}.\n"
+                f"Plugins found: {_available_plugin_modules()}\n"
+                f"tiktoken version: {tiktoken.__version__} (are you on latest?)"
+            )
+
+        constructor = ENCODING_CONSTRUCTORS[encoding_name]
+        enc = Encoding(**constructor())
+        ENCODINGS[encoding_name] = enc
+        return enc
+
+
+def list_encoding_names() -> list[str]:
+    with _lock:
+        if ENCODING_CONSTRUCTORS is None:
+            _find_constructors()
+            assert ENCODING_CONSTRUCTORS is not None
+        return list(ENCODING_CONSTRUCTORS)
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/INSTALLER b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/LICENSE b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..fe15ba1ec5cb967b069af96952c4003477d4de6d
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/LICENSE
@@ -0,0 +1,46 @@
+MIT License
+
+Copyright (c) 2020 tsutsu3
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+===============================================================================
+
+Original Javascript version:
+
+Copyright Mathias Bynens <https://mathiasbynens.be/>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/METADATA b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..fa7f4faaed7d50fd468f8d7d4c2e706fe1d42c5b
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/METADATA
@@ -0,0 +1,51 @@
+Metadata-Version: 2.1
+Name: uc-micro-py
+Version: 1.0.3
+Summary: Micro subset of unicode data files for linkify-it-py projects.
+Author: tsutsu3
+License: MIT
+Project-URL: Homepage, https://github.com/tsutsu3/uc.micro-py
+Keywords: unicode
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: coverage ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+
+# uc.micro-py
+
+[![pypi](https://img.shields.io/pypi/v/uc-micro-py)](https://pypi.org/project/uc-micro-py/)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/uc-micro-py/badges/version.svg)](https://anaconda.org/conda-forge/uc-micro-py)
+[![CI](https://github.com/tsutsu3/uc.micro-py/workflows/CI/badge.svg?branch=main)](https://github.com/tsutsu3/uc.micro-py/actions)
+[![codecov](https://codecov.io/gh/tsutsu3/uc.micro-py/branch/main/graph/badge.svg?token=5Y7559D69U)](https://codecov.io/gh/tsutsu3/uc.micro-py)
+
+This is a Python port of [uc.micro](https://github.com/markdown-it/uc.micro).
+
+> Micro subset of unicode data files for [linkify-it-py](https://github.com/tsutsu3/linkify-it-py) projects.
+
+**This package content is ONLY for [linkify-it-py](https://github.com/tsutsu3/linkify-it-py)projects needs.**
+
+## install
+
+```bash
+pip install uc-micro-py
+```
+
+or
+
+```bash
+conda install -c conda-forge uc-micro-py
+```
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/RECORD b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..f324f1e8558ce822594e2ee488cd77cf87993aa7
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/RECORD
@@ -0,0 +1,33 @@
+uc_micro/__init__.py,sha256=d0NhWg6efnVA_NN2URVk1U0P5GwA5wUxxR2xyf6pxyE,88
+uc_micro/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/categories/Cc/__init__.py,sha256=uB3S74BlYDkBg97bovX6TTQ2h2e6rFWo44vhL1D-5nA,25
+uc_micro/categories/Cc/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/categories/Cc/__pycache__/regex.cpython-310.pyc,,
+uc_micro/categories/Cc/regex.py,sha256=WISqYtoeKenz0rW3ptO0soSbwkylUGY5ulmwMWiHXmY,30
+uc_micro/categories/Cf/__init__.py,sha256=uB3S74BlYDkBg97bovX6TTQ2h2e6rFWo44vhL1D-5nA,25
+uc_micro/categories/Cf/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/categories/Cf/__pycache__/regex.cpython-310.pyc,,
+uc_micro/categories/Cf/regex.py,sha256=Sk5ebdO3zaOba4aKWJIt-Xga2FMsj9c_Vyn0neS6uSc,239
+uc_micro/categories/P/__init__.py,sha256=uB3S74BlYDkBg97bovX6TTQ2h2e6rFWo44vhL1D-5nA,25
+uc_micro/categories/P/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/categories/P/__pycache__/regex.cpython-310.pyc,,
+uc_micro/categories/P/regex.py,sha256=D25po3v3iRc4clxM-BQQA-ju-bWhbErUsLTHs8vlMZY,1916
+uc_micro/categories/Z/__init__.py,sha256=uB3S74BlYDkBg97bovX6TTQ2h2e6rFWo44vhL1D-5nA,25
+uc_micro/categories/Z/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/categories/Z/__pycache__/regex.cpython-310.pyc,,
+uc_micro/categories/Z/regex.py,sha256=ZSzA2L1KbM3xdCrSOhOvtE0PKhUfuPzdwDW41oIWarQ,68
+uc_micro/categories/__init__.py,sha256=2_z1LJ4hXk9_YwI5adYFg8qVi6N4ecxYnjya7anKPAQ,70
+uc_micro/categories/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/properties/Any/__init__.py,sha256=uB3S74BlYDkBg97bovX6TTQ2h2e6rFWo44vhL1D-5nA,25
+uc_micro/properties/Any/__pycache__/__init__.cpython-310.pyc,,
+uc_micro/properties/Any/__pycache__/regex.cpython-310.pyc,,
+uc_micro/properties/Any/regex.py,sha256=HjYxrjVuhxHYNs4fsdyksRMOa6kqMrZl1FyYzJ4mfWQ,154
+uc_micro/properties/__init__.py,sha256=z5HFh59hNi9PXt7J_Nf6vlVFbZJ6JL2g4kbLpXPlxKw,19
+uc_micro/properties/__pycache__/__init__.cpython-310.pyc,,
+uc_micro_py-1.0.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+uc_micro_py-1.0.3.dist-info/LICENSE,sha256=JwyU4aIqyl6yj05nSQBiUwsxmy9h0vXVU5CCjVl2CpU,2253
+uc_micro_py-1.0.3.dist-info/METADATA,sha256=TGeiMO023cQ5Q2NjxQonEoTiwKpGgO2RqnJ4e8iQ5z0,1967
+uc_micro_py-1.0.3.dist-info/RECORD,,
+uc_micro_py-1.0.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uc_micro_py-1.0.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+uc_micro_py-1.0.3.dist-info/top_level.txt,sha256=kfrkaPtFKrnzApVVQj6dkhi_IARLQ23p5DAw5poBTNw,9
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/REQUESTED b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/WHEEL b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..98c0d20b7a64f4f998d7913e1d38a05dba20916c
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/top_level.txt b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e0bf4960e3a97acbf8f6715285ff5a19b13b77d
--- /dev/null
+++ b/evalkit_internvl/lib/python3.10/site-packages/uc_micro_py-1.0.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+uc_micro