def adjust_contrast_sigmoid(arr, gain, cutoff):
<EOL>if arr.dtype.name == "<STR_LIT>":<EOL><INDENT>min_value, _center_value, max_value = iadt.get_value_range_of_dtype(arr.dtype)<EOL>dynamic_range = max_value - min_value<EOL>value_range = np.linspace(<NUM_LIT:0>, <NUM_LIT:1.0>, num=dynamic_range+<NUM_LIT:1>, dtype=np.float32)<EOL>gain = np.float32(gain)<EOL>cutoff = np.float32(cutoff)<EOL>table = min_value + dynamic_range * <NUM_LIT:1>/(<NUM_LIT:1> + np.exp(gain * (cutoff - value_range)))<EOL>arr_aug = cv2.LUT(arr, np.clip(table, min_value, max_value).astype(arr.dtype))<EOL>if arr.ndim == <NUM_LIT:3> and arr_aug.ndim == <NUM_LIT:2>:<EOL><INDENT>return arr_aug[..., np.newaxis]<EOL><DEDENT>return arr_aug<EOL><DEDENT>else:<EOL><INDENT>return ski_exposure.adjust_sigmoid(arr, cutoff=cutoff, gain=gain)<EOL><DEDENT>
Adjust contrast by scaling each pixel value to ``255 * 1/(1 + exp(gain*(cutoff - I_ij/255)))``.

dtype support::

    * ``uint8``: yes; fully tested (1) (2) (3)
    * ``uint16``: yes; tested (2) (3)
    * ``uint32``: yes; tested (2) (3)
    * ``uint64``: yes; tested (2) (3) (4)
    * ``int8``: limited; tested (2) (3) (5)
    * ``int16``: limited; tested (2) (3) (5)
    * ``int32``: limited; tested (2) (3) (5)
    * ``int64``: limited; tested (2) (3) (4) (5)
    * ``float16``: limited; tested (5)
    * ``float32``: limited; tested (5)
    * ``float64``: limited; tested (5)
    * ``float128``: no (6)
    * ``bool``: no (7)

    - (1) Handled by ``cv2``. Other dtypes are handled by ``skimage``.
    - (2) Normalization is done as ``I_ij/max``, where ``max`` is the maximum value of the
          dtype, e.g. 255 for ``uint8``. The normalization is reversed afterwards,
          e.g. ``result*255`` for ``uint8``.
    - (3) Integer-like values are not rounded after applying the contrast adjustment equation
          (before inverting the normalization to 0.0-1.0 space), i.e. projection from continuous
          space to discrete happens according to floor function.
    - (4) Note that scikit-image doc says that integers are converted to ``float64`` values before
          applying the contrast normalization method. This might lead to inaccuracies for large
          64bit integer values. Tests showed no indication of that happening though.
    - (5) Must not contain negative values. Values >=0 are fully supported.
    - (6) Leads to error in scikit-image.
    - (7) Does not make sense for contrast adjustments.

Parameters
----------
arr : numpy.ndarray
    Array for which to adjust the contrast. Dtype ``uint8`` is fastest.

gain : number
    Multiplier for the sigmoid function's output.
    Higher values lead to quicker changes from dark to light pixels.

cutoff : number
    Cutoff that shifts the sigmoid function in horizontal direction.
    Higher values mean that the switch from dark to light pixels happens later, i.e.
    the pixels will remain darker.

Returns
-------
numpy.ndarray
    Array with adjusted contrast.