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 of the given coordinate.
  
          Parameters
          ----------
          %(CFDecoder.get_triangles.parameters)s
  
          Returns
          -------
          %(CFDecoder.get_triangles.returns)s
  
          Notes
          -----
          If the ``'location'`` attribute is set to ``'node'``, a delaunay
          triangulation is performed using the
          :class:`matplotlib.tri.Triangulation` class.
  
          .. todo::
              Implement the visualization for UGrid data shown on the edge of the
              triangles"""
          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
  
          if coords is None:
              coords = self.ds.coords
  
          def get_coord(coord):
              return coords.get(coord, self.ds.coords.get(coord))
  
          mesh = self.get_mesh(var, coords)
          nodes = self.get_nodes(mesh, coords)
          if any(n is None for n in nodes):
              raise ValueError("Could not find the nodes variables!")
          xvert, yvert = nodes
          xvert = xvert.values
          yvert = yvert.values
          loc = var.attrs.get('location', 'face')
          if loc == 'face':
              triangles = get_coord(
                  mesh.attrs.get('face_node_connectivity', '')).values
              if triangles is None:
                  raise ValueError(
                      "Could not find the connectivity information!")
          elif loc == 'node':
              triangles = None
          else:
              raise ValueError(
                  "Could not interprete location attribute (%s) of mesh "
                  "variable %s!" % (loc, mesh.name))
  
          if convert_radian:
              for coord in nodes:
                  if coord.attrs.get('units') == 'radian':
                      coord = coord * 180. / np.pi
          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, ))
              xvert = xvert[triangles].ravel()
              yvert = yvert[triangles].ravel()
              arr = target_crs.transform_points(src_crs, xvert, yvert)
              xvert = arr[:, 0]
              yvert = arr[:, 1]
              if loc == 'face':
                  triangles = np.reshape(range(len(xvert)), (len(xvert) // 3,
                                                             3))
  
          return Triangulation(xvert, yvert, triangles)