
    89j?                     T    d Z ddlZddlmZ ddlmZ ddlmZ ddZ		 ddd	d
Z
ddZy)z0Implementation of various restoration functions.    N)convolve   )_supported_float_type   )uftc                    |/t        j                  | j                  | j                  |      \  }}t	        j
                  |      s"t        j                  || j                  |      }t        | j                        }| j                  |d      } |j                  j                  |d      }|j                  j                  |d      }|j                  |j                  k7  r#t        j                  || j                  |      }n|}t	        j                  |      t	        j                  |      dz  |t	        j                  |      dz  z  z   z  }	|r8t        j                  |	t        j                  |       z  | j                        }
n+t        j                  |	t        j                   |       z        }
|rd|
|
dkD  <   d|
|
dk  <   |
S )u1  Restore image using Wiener–Hunt deconvolution.

    Wiener–Hunt deconvolution is a restoration method which follows a Bayesian
    approach [1]_.

    Parameters
    ----------
    image : (N1, N2, ..., ND) ndarray
       Degraded image.
    psf : ndarray
       Point spread function (PSF). Assumed to be the impulse
       response (input image space) if the data type is real, or the
       transfer function (Fourier or frequency space) if the data type is
       complex. There is no constraint on the shape of the impulse
       response. The transfer function though must be of shape
       `(N1, N2, ..., ND)` if `is_real is True`,
       `(N1, N2, ..., ND // 2 + 1)` otherwise (see :func:`numpy.fft.rfftn`).
    balance : float
       Regularization parameter. Denoted by :math:`\lambda`: in the Notes
       section below, its value lets you balance data adequacy (improving
       frequency restoration) with respect to prior adequacy (reducing
       frequency restoration and avoiding noise artifacts). A larger value for
       this parameter favors the regularization/prior.
    reg : ndarray, optional
       Regularization operator. Laplacian by default. It can
       be an impulse response or a transfer function, as for the PSF.
       Shape constraints are the same as for `psf`.
    is_real : bool, optional
       True by default. Specify if `psf` and `reg` are provided over just half
       the frequency space (thanks to the redundancy of the Fourier transform
       for real signals). Applies only if `psf` and/or `reg` are
       provided as transfer functions.
       See ``uft`` module and :func:`np.fft.rfftn`.
    clip : bool, optional
       True by default. If True, pixel values of the deconvolved image (which
       is the return value) above 1 (resp. below -1) are clipped to 1 (resp.
       to -1). Be careful to set `clip=False` if you do not want this clipping
       and/or if your data range is not [0, 1] or [-1,1].

    Returns
    -------
    im_deconv : (N1, N2, ..., ND) ndarray
       The deconvolved image.

    Examples
    --------
    >>> import skimage as ski
    >>> import scipy as sp
    >>> img = ski.color.rgb2gray(ski.data.astronaut())
    >>> psf = np.ones((5, 5)) / 25
    >>> img = sp.signal.convolve2d(img, psf, 'same')
    >>> rng = np.random.default_rng()
    >>> img += 0.1 * img.std() * rng.standard_normal(img.shape)
    >>> deconvolved_img = ski.restoration.wiener(img, psf, 0.1)

    Notes
    -----
    This function applies the Wiener filter to a noisy (degraded)
    image by an impulse response (or PSF). If the data model is

    .. math:: y = Hx + n

    where :math:`n` is noise, :math:`H` the PSF, and :math:`x` the
    unknown original image, the Wiener filter is

    .. math::
       \hat x = F^\dagger \left( |\Lambda_H|^2 + \lambda |\Lambda_D|^2 \right)^{-1}
       \Lambda_H^\dagger F y

    where :math:`F` and :math:`F^\dagger` are the Fourier and inverse
    Fourier transforms respectively, :math:`\Lambda_H` the transfer
    function (or the Fourier transform of the PSF, see [2]_),
    and :math:`\Lambda_D` the regularization operator, which is a filter
    penalizing the restored image frequencies (Laplacian by default, that is,
    penalization of high frequencies). The parameter :math:`\lambda` tunes the
    balance between data (which tends to increase high frequencies, even those
    coming from noise) and regularization/prior (which tends to avoid noise
    artifacts).

    These methods are then specific to a prior model. Consequently,
    the application or the true image nature must correspond to the
    prior model. By default, the prior model (Laplacian) introduces
    image smoothness or pixel correlation. It can also be interpreted
    as high-frequency penalization to compensate for the instability of
    the solution with respect to the data (sometimes called noise
    amplification or "explosive" solution).

    Finally, the use of Fourier space implies a circulant property of
    :math:`H`, see [2]_.

    References
    ----------
    .. [1] François Orieux, Jean-François Giovannelli, and Thomas
           Rodet, "Bayesian estimation of regularization and point
           spread function parameters for Wiener–Hunt deconvolution",
           J. Opt. Soc. Am. A 27, 1593–1607 (2010)
           https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593
           https://hal.archives-ouvertes.fr/hal-00674508

    .. [2] B. R. Hunt "A matrix theory proof of the discrete
           convolution theorem", IEEE Trans. on Audio and
           Electroacoustics, vol. au-19, no. 4, pp. 285–288, dec. 1971
    is_realFcopyr   shaper   )r   	laplacianndimr   npiscomplexobjir2tfr   dtypeastyperealconjabsuirfftnurfftnuifftnufftn)imagepsfbalanceregr
   clip_
float_type
trans_funcwiener_filterdeconvs              a/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/skimage/restoration/deconvolution.pywienerr)   
   sc   P {uzz5;;HQ??3iiU[[':&u{{3JLL%L0E
((//*5/
1C
((//*5/
1C
yyCIIYYsEKKA

GGJ'
za'BFF3K1,<"<<M ]SZZ->>ekkRMCIIe,<<=vz v{M    )rngc                   dddddd}|j                  |xs i        |/t        j                  | j                  | j                  |      \  }}t        j                  |      s"t        j                  || j                  |      }t        | j                        }	| j                  |	d	      } |j                  j                  |	d	      }|j                  j                  |	d	      }|j                  |j                  k7  r#t        j                  || j                  |      }
n|}
t        j                  |
j                  |	
      }t        j                  |
j                  |	
      }t
        j                  }dgdg}}t        j                  |      dz  }t        j                  |
      dz  }|rt        j                  |       }nt        j                   |       }t
        j"                  j%                  |      }t'        |d         D ]  }|d   |z  |d   |z  z   }|j)                  |j                        }|j                  |	d	      }|j)                  |j                        }|j                  |	d	      }t        j*                  d|z        |d|z  z   z  }|d   t        j,                  |
      z  |z  }||z  |z   }|d   r |d   |       |j/                  |j1                  | j2                  dz  dt        j4                  |||
z  z
        z               |j/                  |j1                  | j2                  dz
  dz  dt        j4                  ||z        z               ||d   kD  r||z   }||d   dz   kD  rv|||d   z
  z  }|||d   z
  dz
  z  }t        j6                  t        j                  ||z
              t        j6                  t        j                  |            z  ||d   z
  z  }|}||d   kD  s||d   k  s  n ||d   z
  z  }|r"t        j8                  || j                        }nt        j:                  |      }|rd||dkD  <   d||dk  <   |||dfS )u  Unsupervised Wiener-Hunt deconvolution.

    Return the deconvolution with a Wiener-Hunt approach, where the
    hyperparameters are automatically estimated. The algorithm is a
    stochastic iterative process (Gibbs sampler) described in the
    reference below. See also ``wiener`` function.

    Parameters
    ----------
    image : (M, N) ndarray
        The input degraded image.
    psf : ndarray
        The impulse response (input image's space) or the transfer
        function (Fourier space). Both are accepted. The transfer
        function is automatically recognized as being complex
        (``np.iscomplexobj(psf)``).
    reg : ndarray, optional
        The regularisation operator. The Laplacian by default. It can
        be an impulse response or a transfer function, as for the psf.
    user_params : dict, optional
        Dictionary of parameters for the Gibbs sampler. Accepted keys are:

        threshold : float
           The stopping criterion: the norm of the difference between to
           successive approximated solution (empirical mean of object
           samples, see Notes section). 1e-4 by default.
        burnin : int
           The number of sample to ignore to start computation of the
           mean. 15 by default.
        min_num_iter : int
           The minimum number of iterations. 30 by default.
        max_num_iter : int
           The maximum number of iterations if ``threshold`` is not
           satisfied. 200 by default.
        callback : callable
           A user provided callable to which is passed, if the function
           exists, the current image sample for whatever purpose. The user
           can store the sample, or compute other moments than the
           mean. It has no influence on the algorithm execution and is
           only for inspection.

    clip : bool, optional
        True by default. If true, pixel values of the result above 1 or
        under -1 are thresholded for skimage pipeline compatibility.
    rng : {`numpy.random.Generator`, int}, optional
        Pseudo-random number generator.
        By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`).
        If `rng` is an int, it is used to seed the generator.

        .. versionadded:: 0.19

    Returns
    -------
    x_postmean : (M, N) ndarray
        The deconvolved image (the posterior mean).
    chains : dict
        The keys ``noise`` and ``prior`` contain the chain list of
        noise and prior precision respectively.

    Examples
    --------
    >>> from skimage import color, data, restoration
    >>> img = color.rgb2gray(data.astronaut())
    >>> from scipy.signal import convolve2d
    >>> psf = np.ones((5, 5)) / 25
    >>> img = convolve2d(img, psf, 'same')
    >>> rng = np.random.default_rng()
    >>> img += 0.1 * img.std() * rng.standard_normal(img.shape)
    >>> deconvolved_img = restoration.unsupervised_wiener(img, psf)

    Notes
    -----
    The estimated image is design as the posterior mean of a
    probability law (from a Bayesian analysis). The mean is defined as
    a sum over all the possible images weighted by their respective
    probability. Given the size of the problem, the exact sum is not
    tractable. This algorithm use of MCMC to draw image under the
    posterior law. The practical idea is to only draw highly probable
    images since they have the biggest contribution to the mean. At the
    opposite, the less probable images are drawn less often since
    their contribution is low. Finally, the empirical mean of these
    samples give us an estimation of the mean, and an exact
    computation with an infinite sample set.

    References
    ----------
    .. [1] François Orieux, Jean-François Giovannelli, and Thomas
           Rodet, "Bayesian estimation of regularization and point
           spread function parameters for Wiener-Hunt deconvolution",
           J. Opt. Soc. Am. A 27, 1593-1607 (2010)

           https://www.osapublishing.org/josaa/abstract.cfm?URI=josaa-27-7-1593

           https://hal.archives-ouvertes.fr/hal-00674508
    g-C6?         N)	thresholdmax_num_itermin_num_iterburnincallbackr	   Fr   r   r   r   r1   r         ?y              ?r4   r3   r2   r0   r   )noiseprior)updater   r   r   r   r   r   r   r   r   r   r   zerosnanr   urfft2ufft2randomdefault_rngrangestandard_normalsqrtr   appendgammasizeimage_quad_normsumuirfft2uifft2)r   r   r!   user_paramsr
   r"   r+   paramsr#   r$   	trans_fct
x_postmeanprev_x_postmeandeltagn_chaingx_chainareg2atf2data_spectrum	iteration	precision_rand1_rand2	excursionr&   x_samplecurrentpreviouss                               r(   unsupervised_wienerr]      s0   F F MM+#$
{uzz5;;HQ??3iiU[[':&u{{3JLL%L0E
((//*5/
1C
((//*5/
1C
yyCIIIIc5;;@		 )//<JhhyjAO FFE qchH FF3K1E66)!D 

5)		%(
))


$C 6.12 5	 RL4'(2,*>>	 $$]%8%89z6$$]%8%89z6GGC)O,f0DE	 !rwwy'99IE !=09<*F:x( 	II

QC''98L(LMM	
 	IIuzzA~*A0C0CHsN0S,ST	

 vh''(83Jx(1,- Ix0@$@AG&)fX6F*F*JKH rvvg012&&
+,-vh//1  % ~..UVK=P5Pk5p y6(+;;<J[[5;;?
ZZ
+
%&
:>"&(
:?#(X>??r*   c                    t        | j                        }| j                  |d      } |j                  |d      }t        j                  | j
                  d|      }t        j                  |      }d}t        |      D ]I  }	t        ||d      |z   }
|rt        j                  |
|k  d| |
z        }n| |
z  }|t        ||d      z  }K |rd	||d	kD  <   d
||d
k  <   |S )a  Richardson-Lucy deconvolution.

    Parameters
    ----------
    image : ([P, ]M, N) ndarray
       Input degraded image (can be n-dimensional). If you keep the
       default `clip=True` parameter, you may want to normalize
       the image so that its values fall in the [-1, 1] interval to avoid
       information loss.
    psf : ndarray
       The point spread function.
    num_iter : int, optional
       Number of iterations. This parameter plays the role of
       regularisation.
    clip : bool, optional
       True by default. If true, pixel value of the result above 1 or
       under -1 are thresholded for skimage pipeline compatibility.
    filter_epsilon : float, optional
       Value below which intermediate results become 0 to avoid division
       by small numbers.

    Returns
    -------
    im_deconv : ndarray
       The deconvolved image.

    Examples
    --------
    >>> from skimage import img_as_float, data, restoration
    >>> camera = img_as_float(data.camera())
    >>> from scipy.signal import convolve2d
    >>> psf = np.ones((5, 5)) / 25
    >>> camera = convolve2d(camera, psf, 'same')
    >>> rng = np.random.default_rng()
    >>> camera += 0.1 * camera.std() * rng.standard_normal(camera.shape)
    >>> deconvolved = restoration.richardson_lucy(camera, psf, 5)

    References
    ----------
    .. [1] https://en.wikipedia.org/wiki/Richardson%E2%80%93Lucy_deconvolution
    Fr   r6   r5   g-q=same)moder   r   r   )
r   r   r   r   fullr   flipr@   r   where)r   r   num_iterr"   filter_epsilonr$   	im_deconv
psf_mirrorepsr#   convrelative_blurs               r(   richardson_lucyrk   g  s    T 'u{{3JLL%L0E
**Ze*
,CS
;IJ C8_ F	3V4s:HHTN%:Aut|LM!DLMXmZfEE	F #$	)a- $&	)b.!r*   )NTT)NNTT)2   TN)__doc__numpyr   scipy.signalr   _shared.utilsr    r   r)   r]   rk    r*   r(   <module>rs      s9    6  ! 1 BL @DU@LPU@p?r*   