class_docstr: Convert non-snowy landscapes to snowy ones.
  
  This augmenter expects to get an image that roughly shows a landscape.
  
  This augmenter is based on the method proposed in
  https://medium.freecodecamp.org/image-augmentation-make-it-rain-make-it-snow-how-to-modify-a-photo-with-machine-learning-163c0cb3843f?gi=bca4a13e634c
  
  **Supported dtypes**:
  
      * ``uint8``: yes; fully tested
      * ``uint16``: no (1)
      * ``uint32``: no (1)
      * ``uint64``: no (1)
      * ``int8``: no (1)
      * ``int16``: no (1)
      * ``int32``: no (1)
      * ``int64``: no (1)
      * ``float16``: no (1)
      * ``float32``: no (1)
      * ``float64``: no (1)
      * ``float128``: no (1)
      * ``bool``: no (1)
  
      - (1) This augmenter is based on a colorspace conversion to HLS.
            Hence, only RGB ``uint8`` inputs are sensible.
  
  Parameters
  ----------
  lightness_threshold : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional
      All pixels with lightness in HLS colorspace that is below this value
      will have their lightness increased by `lightness_multiplier`.
  
          * If a ``number``, then that value will always be used.
          * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled
            per image from the discrete interval ``[a..b]``.
          * If a ``list``, then a random value will be sampled from that
            ``list`` per image.
          * If a ``StochasticParameter``, then a value will be sampled
            per image from that parameter.
  
  lightness_multiplier : number or tuple of number or list of number or imgaug.parameters.StochasticParameter, optional
      Multiplier for pixel's lightness value in HLS colorspace.
      Affects all pixels selected via `lightness_threshold`.
  
          * If a ``number``, then that value will always be used.
          * If a ``tuple`` ``(a, b)``, then a value will be uniformly sampled
            per image from the discrete interval ``[a..b]``.
          * If a ``list``, then a random value will be sampled from that
            ``list`` per image.
          * If a ``StochasticParameter``, then a value will be sampled
            per image from that parameter.
  
  from_colorspace : str, optional
      The source colorspace of the input images.
      See :func:`~imgaug.augmenters.color.ChangeColorspace.__init__`.
  
  seed : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional
      See :func:`~imgaug.augmenters.meta.Augmenter.__init__`.
  
  name : None or str, optional
      See :func:`~imgaug.augmenters.meta.Augmenter.__init__`.
  
  random_state : None or int or imgaug.random.RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState, optional
      Old name for parameter `seed`.
      Its usage will not yet cause a deprecation warning,
      but it is still recommended to use `seed` now.
      Outdated since 0.4.0.
  
  deterministic : bool, optional
      Deprecated since 0.4.0.
      See method ``to_deterministic()`` for an alternative and for
      details about what the "deterministic mode" actually does.
  
  Examples
  --------
  >>> import imgaug.augmenters as iaa
  >>> aug = iaa.FastSnowyLandscape(
  >>>     lightness_threshold=140,
  >>>     lightness_multiplier=2.5
  >>> )
  
  Search for all pixels in the image with a lightness value in HLS
  colorspace of less than ``140`` and increase their lightness by a factor
  of ``2.5``.
  
  >>> aug = iaa.FastSnowyLandscape(
  >>>     lightness_threshold=[128, 200],
  >>>     lightness_multiplier=(1.5, 3.5)
  >>> )
  
  Search for all pixels in the image with a lightness value in HLS
  colorspace of less than ``128`` or less than ``200`` (one of these
  values is picked per image) and multiply their lightness by a factor
  of ``x`` with ``x`` being sampled from ``uniform(1.5, 3.5)`` (once per
  image).
  
  >>> aug = iaa.FastSnowyLandscape(
  >>>     lightness_threshold=(100, 255),
  >>>     lightness_multiplier=(1.0, 4.0)
  >>> )
  
  Similar to the previous example, but the lightness threshold is sampled
  from ``uniform(100, 255)`` (per image) and the multiplier
  from ``uniform(1.0, 4.0)`` (per image). This seems to produce good and
  varied results.
docstr: See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`.
docstr_tok: ["See",":","func",":","`","~imgaug.augmenters.meta.Augmenter.get_parameters","`","."]
code: def get_parameters(self):
      """See :func:`~imgaug.augmenters.meta.Augmenter.get_parameters`."""
      return [self.lightness_threshold, self.lightness_multiplier]
  
imports: from __future__ import print_function, division, absolute_import
  import numpy
  import imgaug
  from .None import meta, arithmetic, blur, contrast, color
  from ..None import parameters
  from ..None import dtypes
label_desc: Use image node_id 4 for calling the FastSnowyLandscape obj's underlying member method code with example usage: obj.get_parameters() and returns: list