docs: def Beach(fm, linewidth=2, facecolor='b', bgcolor='w', edgecolor='k',
            alpha=1.0, xy=(0, 0), width=200, size=100, nofill=False,
            zorder=100, axes=None):
      """
      Return a beach ball as a collection which can be connected to an
      current matplotlib axes instance (ax.add_collection).
  
      S1, D1, and R1, the strike, dip and rake of one of the focal planes, can
      be vectors of multiple focal mechanisms.
  
      :param fm: Focal mechanism that is either number of mechanisms (NM) by 3
          (strike, dip, and rake) or NM x 6 (M11, M22, M33, M12, M13, M23 - the
          six independent components of the moment tensor, where the coordinate
          system is 1,2,3 = Up,South,East which equals r,theta,phi). The strike
          is of the first plane, clockwise relative to north.
          The dip is of the first plane, defined clockwise and perpendicular to
          strike, relative to horizontal such that 0 is horizontal and 90 is
          vertical. The rake is of the first focal plane solution. 90 moves the
          hanging wall up-dip (thrust), 0 moves it in the strike direction
          (left-lateral), -90 moves it down-dip (normal), and 180 moves it
          opposite to strike (right-lateral).
      :param facecolor: Color to use for quadrants of tension; can be a string,
          e.g. ``'r'``, ``'b'`` or three component color vector, [R G B].
          Defaults to ``'b'`` (blue).
      :param bgcolor: The background color. Defaults to ``'w'`` (white).
      :param edgecolor: Color of the edges. Defaults to ``'k'`` (black).
      :param alpha: The alpha level of the beach ball. Defaults to ``1.0``
          (opaque).
      :param xy: Origin position of the beach ball as tuple. Defaults to
          ``(0, 0)``.
      :type width: int or tuple
      :param width: Symbol size of beach ball, or tuple for elliptically
          shaped patches. Defaults to size ``200``.
      :param size: Controls the number of interpolation points for the
          curves. Minimum is automatically set to ``100``.
      :param nofill: Do not fill the beach ball, but only plot the planes.
      :param zorder: Set zorder. Artists with lower zorder values are drawn
          first.
      :type axes: :class:`matplotlib.axes.Axes`
      :param axes: Used to make beach balls circular on non-scaled axes. Also
          maintains the aspect ratio when resizing the figure. Will not add
          the returned collection to the axes instance.
      """
      # check if one or two widths are specified (Circle or Ellipse)
      try:
          assert(len(width) == 2)
      except TypeError:
          width = (width, width)
      mt = None
      np1 = None
      if isinstance(fm, MomentTensor):
          mt = fm
          np1 = MT2Plane(mt)
      elif isinstance(fm, NodalPlane):
          np1 = fm
      elif len(fm) == 6:
          mt = MomentTensor(fm[0], fm[1], fm[2], fm[3], fm[4], fm[5], 0)
          np1 = MT2Plane(mt)
      elif len(fm) == 3:
          np1 = NodalPlane(fm[0], fm[1], fm[2])
      else:
          raise TypeError("Wrong input value for 'fm'.")
  
      # Only at least size 100, i.e. 100 points in the matrix are allowed
      if size < 100:
          size = 100
  
      # Return as collection
      if mt:
          (T, N, P) = MT2Axes(mt)
          if np.fabs(N.val) < EPSILON and np.fabs(T.val + P.val) < EPSILON:
              colors, p = plotDC(np1, size, xy=xy, width=width)
          else:
              colors, p = plotMT(T, N, P, size,
                                 plot_zerotrace=True, xy=xy, width=width)
      else:
          colors, p = plotDC(np1, size=size, xy=xy, width=width)
  
      if nofill:
          # XXX: not tested with plotMT
          col = collections.PatchCollection([p[1]], match_original=False)
          col.set_facecolor('none')
      else:
          col = collections.PatchCollection(p, match_original=False)
          # Replace color dummies 'b' and 'w' by face and bgcolor
          fc = [facecolor if c == 'b' else bgcolor for c in colors]
          col.set_facecolors(fc)
  
      # Use the given axes to maintain the aspect ratio of beachballs on figure
      # resize.
      if axes is not None:
          # This is what holds the aspect ratio (but breaks the positioning)
          col.set_transform(transforms.IdentityTransform())
          # Next is a dirty hack to fix the positioning:
          # 1. Need to bring the all patches to the origin (0, 0).
          for p in col._paths:
              p.vertices -= xy
          # 2. Then use the offset property of the collection to position the
          #    patches
          col.set_offsets(xy)
          col._transOffset = axes.transData
  
      col.set_edgecolor(edgecolor)
      col.set_alpha(alpha)
      col.set_linewidth(linewidth)
      col.set_zorder(zorder)
      return col