code: def prewitt(image, mask=None, *, axis=None, mode="reflect", cval=0.0):
      """Find the edge magnitude using the Prewitt transform.
  
      Parameters
      ----------
      image : array
          The input image.
      mask : array of bool, optional
          Clip the output image to this mask. (Values where mask=0 will be set
          to 0.)
      axis : int or sequence of int, optional
          Compute the edge filter along this axis. If not provided, the edge
          magnitude is computed. This is defined as::
  
              prw_mag = np.sqrt(sum([prewitt(image, axis=i)**2
                                     for i in range(image.ndim)]) / image.ndim)
  
          The magnitude is also computed if axis is a sequence.
      mode : str or sequence of str, optional
          The boundary mode for the convolution. See `scipy.ndimage.convolve`
          for a description of the modes. This can be either a single boundary
          mode or one boundary mode per axis.
      cval : float, optional
          When `mode` is ``'constant'``, this is the constant used in values
          outside the boundary of the image data.
  
      Returns
      -------
      output : array of float
          The Prewitt edge map.
  
      See also
      --------
      prewitt_h, prewitt_v : horizontal and vertical edge detection.
      sobel, scharr, farid, skimage.feature.canny
  
      Notes
      -----
      The edge magnitude depends slightly on edge directions, since the
      approximation of the gradient operator by the Prewitt operator is not
      completely rotation invariant. For a better rotation invariance, the Scharr
      operator should be used. The Sobel operator has a better rotation
      invariance than the Prewitt operator, but a worse rotation invariance than
      the Scharr operator.
  
      Examples
      --------
      >>> from skimage import data
      >>> from skimage import filters
      >>> camera = data.camera()
      >>> edges = filters.prewitt(camera)
      """
      output = _generic_edge_filter(
          image,
          smooth_weights=PREWITT_SMOOTH,
          axis=axis,
          mode=mode,
          cval=cval,
      )
      output = _mask_filter_result(output, mask)
      return output
  
imports: import numpy
  from scipy import ndimage
  from scipy.ndimage import binary_erosion, convolve
  from .._shared.utils import _supported_float_type, check_nD
  from ..restoration.uft import laplacian
  from ..util.dtype import img_as_float
label_desc: Use image node_id 11 for calling a global function with example usage: prewitt(image, mask) and returns: output