+
    ùäûjb  ã                   ót   € ^ RI HtHtHtHtHt ^ RIt^ RIHt	 ^ RI
Ht ^ RIHtHt ^ RIHt  ! R R]4      tR# )	é    )ÚAnyÚDictÚOptionalÚTupleÚUnionN)Úrandom_generator)ÚIntensityAugmentationBase2D)Ú_clamp_unit_rangeÚ_to_device_nonblocking)Ú	posterizec                   ó\   a a€ ] tR t^t oRtRV3R lV 3R llltRV3R lR lltRtVtV ;t	# )	ÚRandomPosterizeaÏ  Posterize images to a random number of bits, applied per sample with probability ``p`` (default 0.5).

``output = RandomPosterize(bits, ...)(input)`` reduces the retained bit depth of selected images.

.. image:: _static/img/RandomPosterize.png

See the Convention block on :class:`~kornia.augmentation.IntensityAugmentationBase2D`.

Args:
    p: probability of applying the transformation to each sample.
    bits: number of high bits to keep, in ``[0, 8]``, in which 0 gives a black image and 8 gives the
        original. A range of whole numbers is closed and uniform: every integer from the lower to the upper
        bound is drawn with the same probability. A non-integral argument is accepted; the drawn factor is
        rounded to an integer, half to even, so ``2.5`` gives ``2`` and ``3.5`` gives ``4``.
        If int x, bits will be generated from (x, 8) then convert to int.
        If tuple (x, y), bits will be generated from (x, y) then convert to int.
    same_on_batch: apply the same transformation across the batch.
    keepdim: whether to keep the output shape the same as input (True) or broadcast it
             to the batch form (False).

Shape:
    - Input: ``(C, H, W)`` or ``(B, C, H, W)``, Optional: ``(B, 3, 3)``
    - Output: ``(B, C, H, W)``

Convention:
    - input values are clamped into ``[0, 1]`` before the operation, and the result is clamped
      into the same range. This applies only to samples selected by the probability gate.
    - ``bits=(k, k)`` with ``k < 8`` leaves at most ``2 ** k`` distinct values, so ``0`` gives a constant
      image; the reduction is a ``uint8`` round trip inside :func:`kornia.enhance.posterize`. A sample that
      draws ``8`` returns the clamped input, without the round trip.
    - the round trip is a step function: the output still has ``requires_grad=True``, but its gradient with
      respect to the input is identically ``0`` below ``bits=8``, and follows the input clamp at ``8``.
    - an ``int`` argument is the lower bound of the sampled range ``[x, 8]`` -- the opposite reading
      from :class:`RandomSharpness`, whose scalar argument is an upper bound.

.. note::
    This function internally uses :func:`kornia.enhance.posterize`.

See Also:
    - :class:`RandomSolarize`: thresholds values rather than reducing their bit depth.

Examples:
    >>> rng = torch.manual_seed(0)
    >>> input = torch.rand(1, 1, 5, 5)
    >>> posterize = RandomPosterize(3., p=1.)
    >>> posterize(input)
    tensor([[[[0.4863, 0.7529, 0.0784, 0.1255, 0.2980],
              [0.6275, 0.4863, 0.8941, 0.4549, 0.6275],
              [0.3451, 0.3922, 0.0157, 0.1569, 0.2824],
              [0.5176, 0.6902, 0.8000, 0.1569, 0.2667],
              [0.6745, 0.9098, 0.3922, 0.8627, 0.4078]]]])

To apply the exact augmenation again, you may take the advantage of the previous parameter state:
    >>> input = torch.randn(1, 3, 32, 32)
    >>> aug = RandomPosterize(3., p=1.)
    >>> (aug(input) == aug(input, params=aug._params)).all()
    tensor(True)

c          
      óz   <€ V ^8„  d   QhRS[ S[S[S[S[3,          S[P                  3,          RS[RS[RS[RR/# )é   ÚbitsÚsame_on_batchÚpÚkeepdimÚreturnN)r   Úfloatr   ÚtorchÚTensorÚbool)ÚformatÚ__classdict__s   "€ÚgC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\augmentation\_2d\intensity\posterize.pyÚ__annotate__ÚRandomPosterize.__annotate__Y   sV   ø€ ÷ 	<ñ 	<á‘E™5¡© Õ.±·±Ð<Õ=ð	<ñ ð	<ñ ð		<ñ
 ð	<ð 
ñ	<ó    c                ó`   <€ \         SV `  W2VR 7       \        P                  ! V4      V n        R# ))r   r   r   N)ÚsuperÚ__init__ÚrgÚPosterizeGeneratorÚ_param_generator)Úselfr   r   r   r   Ú	__class__s   &&&&&€r   r"   ÚRandomPosterize.__init__Y   s*   ø€ ô 	‰Ñ˜1À7ÐÔKä "× 5Ò 5°dÓ ;ˆÖr   c          
      óÄ   <€ V ^8„  d   QhRS[ P                  RS[S[S[ P                  3,          RS[S[S[3,          RS[S[ P                  ,          RS[ P                  /# )r   ÚinputÚparamsÚflagsÚ	transformr   )r   r   r   Ústrr   r   )r   r   s   "€r   r   r   d   sk   ø€ ÷ ]ñ ]á�|‰|ð]ñ ‘S™%Ÿ,™,Ð&Õ'ð]ñ ‘C™�H�~ð	]ñ
 ™EŸL™LÕ)ð]ñ 
�‰ñ]r   c                óf   € \        V4      p\        V\        VR ,          VP                  4      4      # )Úbits_factor)r
   r   r   Údevice)r&   r*   r+   r,   r-   s   &&&&&r   Úapply_transformÚRandomPosterize.apply_transformd   s,   € ô " %Ó(ˆÜ˜Ô 6°v¸mÕ7LÈeÏlÉlÓ [Ó\Ð\r   )r%   )é   Fg      à?F)N)
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r"   r2   Ú__static_attributes__Ú__classdictcell__Ú__classcell__)r'   r   s   @@r   r   r      s'   ù‡ € ñ:÷x	<õ 	<÷]÷ ]ò ]r   r   )Útypingr   r   r   r   r   r   Úkornia.augmentationr   r#   Ú&kornia.augmentation._2d.intensity.baser	   Úkornia.core.utilsr
   r   Úkornia.enhancer   r   © r   r   Ú<module>rC      s-   ð÷$ 5Õ 4ã å 6Ý Nß GÝ $ôP]Ð1ö P]r   