def apply_aspect(self, position=None):
        """
        Adjust the Axes for a specified data aspect ratio.

        Depending on `.get_adjustable` this will modify either the Axes box
        (position) or the view limits. In the former case, `.get_anchor`
        will affect the position.

        Notes
        -----
        This is called automatically when each Axes is drawn.  You may need
        to call it yourself if you need to update the Axes position and/or
        view limits before the Figure is drawn.

        See Also
        --------
        matplotlib.axes.Axes.set_aspect
            for a description of aspect ratio handling.
        matplotlib.axes.Axes.set_adjustable
            defining the parameter to adjust in order to meet the required
            aspect.
        matplotlib.axes.Axes.set_anchor
            defining the position in case of extra space.
        """
        if position is None:
            position = self.get_position(original=True)

        aspect = self.get_aspect()

        if aspect == 'auto':
            self._set_position(position, which='active')
            return

        if aspect == 'equal':
            aspect = 1

        fig_width, fig_height = self.get_figure().get_size_inches()
        fig_aspect = fig_height / fig_width

        if self._adjustable == 'box':
            if self in self._twinned_axes:
                raise RuntimeError("Adjustable 'box' is not allowed in a "
                                   "twinned Axes; use 'datalim' instead")
            box_aspect = aspect * self.get_data_ratio()
            pb = position.frozen()
            pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)
            self._set_position(pb1.anchored(self.get_anchor(), pb), 'active')
            return

        # self._adjustable == 'datalim'

        # reset active to original in case it had been changed by prior use
        # of 'box'
        self._set_position(position, which='active')

        x_trf = self.xaxis.get_transform()
        y_trf = self.yaxis.get_transform()
        # xmin etc are in data units
        xmin, xmax = map(x_trf.transform, self.get_xbound())
        ymin, ymax = map(y_trf.transform, self.get_ybound())
        # xsize, ysize are the initial screen-unit spans from viewLim
        xsize = max(abs(xmax - xmin), 1e-30)
        ysize = max(abs(ymax - ymin), 1e-30)

        l, b, w, h = position.bounds
        box_aspect = fig_aspect * (h / w)
        data_ratio = box_aspect / aspect  # data ratio to match aspect with box
                                          # It will be used to set the ratio
                                          # *after* transformation to screen
                                          # units, so "data_ratio" is
                                          # perhaps a poor name now that
                                          # transforms are used.
        y_expander = data_ratio * xsize / ysize - 1
        # If y_expander > 0, the dy/dx viewLim ratio needs to increase.
        # y_expander == 0 means the desired data_ratio matches ysize/xsize
        #            > 0 means ysize needs to increase, or xsize needs to
        #                decrease
        if abs(y_expander) < 0.005:
            return

        dL = self.dataLim
        x0, x1 = map(x_trf.transform, dL.intervalx)
        y0, y1 = map(y_trf.transform, dL.intervaly)
        xr = 1.05 * (x1 - x0)
        yr = 1.05 * (y1 - y0)
        # These are like xsize and ysize, but they are taken from dataLim,
        # not viewLim.  Presumably they never change unless an Artist is
        # added or removed.  I think the hardwired margins are a detail;
        # we can investigate whether they should be replaced by actual
        # margins.  They might be playing an important role, though, in
        # switching between two sets of criteria for deciding whether to
        # adjust y or x.

        # Now compare the sizes from transformed viewLim to those from
        # transformed dataLim *with* hardcoded margins...:
        xmarg = xsize - xr  # Positive if viewLim is larger than dataLim
        ymarg = ysize - yr
        # If we keep xsize fixed by changing ysize (in viewLim), what would
        # ysize have to be?  That is Ysize.
        Ysize = data_ratio * xsize
        # And Xsize is what xsize would have to be if ysize is held constant.
        # All of this is still dealing with sizes transformed to screen units.
        Xsize = ysize / data_ratio

        # If we hold ysize constant, how much will the new Xsize differ from
        # its dataLim counterpart, xr?  Will we have extra room available?
        Xmarg = Xsize - xr  # Positive means x viewLim span exceeds dataLim.
        Ymarg = Ysize - yr
        # Setting these targets to, e.g., 0.05*xr does not seem to help.
        xm = 0
        ym = 0

        shared_x = self in self._shared_x_axes
        shared_y = self in self._shared_y_axes
        # Not sure whether we need this check:
        if shared_x and shared_y:
            raise RuntimeError("adjustable='datalim' is not allowed when both "
                               "axes are shared")

        # If y is shared, then we are only allowed to change x, etc.
        if shared_y:
            adjust_y = False
        else:
            if xmarg > xm and ymarg > ym:
                # We have room to spare in both viewLims.
                # Line 1: y_expander < 0 so y needs to shrink relative to x.
                #         Shrink y if we still have extra room after doing so.
                # Line 2: y_expander > 0 so y needs to expand relative to x.
                #         Expand y if the alternative, shrinking x, would
                #         leave us with not enough room for the x dataLim
                adjy = ((Ymarg > 0 and y_expander < 0) or
                        (Xmarg < 0 and y_expander > 0))
            else:
                # This is the usual case once we have zoomed in, because then
                # we normally have at least one axis where we are viewing
                # less than the full data range.  If y viewLim needs to
                # expand, that is the one we adjust; otherwise x.  In other
                # words, the choice is always expansion of one axis *until*
                # we get to the point where we have extra room for *both*
                # axes, so something needs to shrink.
                adjy = y_expander > 0
            adjust_y = shared_x or adjy  # (Ymarg > xmarg)

        if adjust_y:
            yc = 0.5 * (ymin + ymax)
            y0 = yc - Ysize / 2.0
            y1 = yc + Ysize / 2.0
            self.set_ybound(*map(y_trf.inverted().transform, (y0, y1)))
        else:
            xc = 0.5 * (xmin + xmax)
            x0 = xc - Xsize / 2.0
            x1 = xc + Xsize / 2.0
            self.set_xbound(*map(x_trf.inverted().transform, (x0, x1)))