class_docstr: An abstract base class for geographic projections
class_docstr_tok: ["An","abstract","base","class","for","geographic","projections"]
code: def _set_lim_and_transforms(self):
      # A (possibly non-linear) projection on the (already scaled) data
  
      # There are three important coordinate spaces going on here:
      #
      # 1. Data space: The space of the data itself
      #
      # 2. Axes space: The unit rectangle (0, 0) to (1, 1)
      #    covering the entire plot area.
      #
      # 3. Display space: The coordinates of the resulting image,
      #    often in pixels or dpi/inch.
  
      # This function makes heavy use of the Transform classes in
      # ``lib/matplotlib/transforms.py.`` For more information, see
      # the inline documentation there.
  
      # The goal of the first two transformations is to get from the
      # data space (in this case longitude and latitude) to Axes
      # space.  It is separated into a non-affine and affine part so
      # that the non-affine part does not have to be recomputed when
      # a simple affine change to the figure has been made (such as
      # resizing the window or changing the dpi).
  
      # 1) The core transformation from data space into
      # rectilinear space defined in the HammerTransform class.
      self.transProjection = self._get_core_transform(self.RESOLUTION)
  
      # 2) The above has an output range that is not in the unit
      # rectangle, so scale and translate it so it fits correctly
      # within the Axes.  The peculiar calculations of xscale and
      # yscale are specific to an Aitoff-Hammer projection, so don't
      # worry about them too much.
      self.transAffine = self._get_affine_transform()
  
      # 3) This is the transformation from Axes space to display
      # space.
      self.transAxes = BboxTransformTo(self.bbox)
  
      # Now put these 3 transforms together -- from data all the way
      # to display coordinates.  Using the '+' operator, these
      # transforms will be applied "in order".  The transforms are
      # automatically simplified, if possible, by the underlying
      # transformation framework.
      self.transData = (
          self.transProjection + self.transAffine + self.transAxes
      )
  
      # The main data transformation is set up.  Now deal with
      # gridlines and tick labels.
  
      # Longitude gridlines and ticklabels.  The input to these
      # transforms are in display space in x and Axes space in y.
      # Therefore, the input values will be in range (-xmin, 0),
      # (xmax, 1).  The goal of these transforms is to go from that
      # space to display space.  The tick labels will be offset 4
      # pixels from the equator.
      self._xaxis_pretransform = (
          Affine2D()
          .scale(1.0, self._longitude_cap * 2.0)
          .translate(0.0, -self._longitude_cap)
      )
      self._xaxis_transform = self._xaxis_pretransform + self.transData
      self._xaxis_text1_transform = (
          Affine2D().scale(1.0, 0.0)
          + self.transData
          + Affine2D().translate(0.0, 4.0)
      )
      self._xaxis_text2_transform = (
          Affine2D().scale(1.0, 0.0)
          + self.transData
          + Affine2D().translate(0.0, -4.0)
      )
  
      # Now set up the transforms for the latitude ticks.  The input to
      # these transforms are in Axes space in x and display space in
      # y.  Therefore, the input values will be in range (0, -ymin),
      # (1, ymax).  The goal of these transforms is to go from that
      # space to display space.  The tick labels will be offset 4
      # pixels from the edge of the Axes ellipse.
      yaxis_stretch = (
          Affine2D().scale(np.pi * 2, 1).translate(-np.pi, 0)
      )
      yaxis_space = Affine2D().scale(1.0, 1.1)
      self._yaxis_transform = yaxis_stretch + self.transData
      yaxis_text_base = (
          yaxis_stretch
          + self.transProjection
          + (yaxis_space + self.transAffine + self.transAxes)
      )
      self._yaxis_text1_transform = (
          yaxis_text_base + Affine2D().translate(-8.0, 0.0)
      )
      self._yaxis_text2_transform = (
          yaxis_text_base + Affine2D().translate(8.0, 0.0)
      )
  
imports: import numpy
  import matplotlib
  from matplotlib.axes import Axes
  import matplotlib.axis
  from matplotlib.patches import Circle
  from matplotlib.path import Path
  from matplotlib.projections import register_projection
  import matplotlib.spines
  from matplotlib.ticker import FixedLocator, Formatter, NullLocator
  from matplotlib.transforms import Affine2D, BboxTransformTo, Transform
label_desc: Use image node_id 3 for calling the GeoAxes obj's underlying member method code with example usage: obj._set_lim_and_transforms() without return types