code: def sigmaG(a, axis=None, overwrite_input=False, keepdims=False):
      """Compute the rank-based estimate of the standard deviation
  
      Parameters
      ----------
      a : array_like
          Array containing numbers whose mean is desired. If `a` is not an
          array, a conversion is attempted.
      axis : int, optional
          Axis along which the means are computed. The default is to compute
          the mean of the flattened array.
      overwrite_input : bool, optional
         If True, then allow use of memory of input array `a` for
         calculations. The input array will be modified by the call to
         median. This will save memory when you do not need to preserve
         the contents of the input array. Treat the input as undefined,
         but it will probably be fully or partially sorted.
         Default is False. Note that, if `overwrite_input` is True and the
         input is not already an array, an error will be raised.
      keepdims : bool, optional
          If this is set to True, the axes which are reduced are left
          in the result as dimensions with size one. With this option,
          the result will broadcast correctly against the original `arr`.
  
      Returns
      -------
      median : ndarray, see dtype parameter above
          array containing the median values
  
      sigmaG : ndarray, see dtype parameter above.
          array containing the robust estimator of the standard deviation
  
      See Also
      --------
      median_sigmaG : robust rank-based estimate of mean and standard deviation
  
      Notes
      -----
      This routine uses a single call to ``np.percentile`` to find the
      quartiles along the given axis, and uses these to compute the
      sigmaG, a robust estimate of the standard deviation sigma:
  
      sigmaG = 0.7413 * (q75 - q25)
  
      where 0.7413 ~ 1 / (2 sqrt(2) erf^-1(0.5))
      """
      q25, q75 = np.percentile(
          a, [25, 75], axis=axis, overwrite_input=overwrite_input
      )
      sigmaG = sigmaG_factor * (q75 - q25)
  
      if keepdims:
          if axis is None:
              newshape = a.ndim * (1,)
          else:
              newshape = np.asarray(a.shape)
              newshape[axis] = 1
  
          sigmaG = sigmaG.reshape(newshape)
  
      return sigmaG
  
imports: import numpy
  from scipy import stats
label_desc: Use image node_id 3 for calling a global function with example usage: sigmaG(a, axis, overwrite_input, keepdims) and returns: sigmaG