docs: def get_triangles(self, var, coords=None, convert_radian=True,
                        copy=False, src_crs=None, target_crs=None,
                        nans=None, stacklevel=1):
          """
          Get the triangles for the variable
  
          Parameters
          ----------
          var: xarray.Variable or xarray.DataArray
              The variable to use
          coords: dict
              Alternative coordinates to use. If None, the coordinates of the
              :attr:`ds` dataset are used
          convert_radian: bool
              If True and the coordinate has units in 'radian', those are
              converted to degrees
          copy: bool
              If True, vertice arrays are copied
          src_crs: cartopy.crs.Crs
              The source projection of the data. If not None, a transformation
              to the given `target_crs` will be done
          target_crs: cartopy.crs.Crs
              The target projection for which the triangles shall be transformed.
              Must only be provided if the `src_crs` is not None.
          %(CFDecoder._check_triangular_bounds.parameters.nans)s
  
          Returns
          -------
          matplotlib.tri.Triangulation
              The spatial triangles of the variable
  
          Raises
          ------
          ValueError
              If `src_crs` is not None and `target_crs` is None"""
          warn("The 'get_triangles' method is depreceated and will be removed "
               "soon! Use the 'get_cell_node_coord' method!",
               DeprecationWarning, stacklevel=stacklevel)
          from matplotlib.tri import Triangulation
  
          def get_vertices(axis):
              bounds = self._check_triangular_bounds(var, coords=coords,
                                                     axis=axis, nans=nans)[1]
              if coords is not None:
                  bounds = coords.get(bounds.name, bounds)
              vertices = bounds.values.ravel()
              if convert_radian:
                  coord = getattr(self, 'get_' + axis)(var)
                  if coord.attrs.get('units') == 'radian':
                      vertices = vertices * 180. / np.pi
              return vertices if not copy else vertices.copy()
  
          if coords is None:
              coords = self.ds.coords
  
          xvert = get_vertices('x')
          yvert = get_vertices('y')
          if src_crs is not None and src_crs != target_crs:
              if target_crs is None:
                  raise ValueError(
                      "Found %s for the source crs but got None for the "
                      "target_crs!" % (src_crs, ))
              arr = target_crs.transform_points(src_crs, xvert, yvert)
              xvert = arr[:, 0]
              yvert = arr[:, 1]
          triangles = np.reshape(range(len(xvert)), (len(xvert) // 3, 3))
          return Triangulation(xvert, yvert, triangles)