
    |h7                      v    d dl Zd dlmZ ddlmZ ddlmZmZm	Z	 g dZ
d Zd Zd	d
dZdddZd ZdddZy)    N)entropy   )dtype_range)_supported_float_typecheck_shape_equalitywarn)mean_squared_errornormalized_root_msepeak_signal_noise_rationormalized_mutual_informationc                     t        | j                  |j                  f      }t        j                  | |      } t        j                  ||      }| |fS )zK
    Promote im1, im2 to nearest appropriate floating point precision.
    dtype)r   r   npasarray)image0image1
float_types      ]/var/www/html/test/engine/venv/lib/python3.12/site-packages/skimage/metrics/simple_metrics.py
_as_floatsr      sE     'fll'CDJZZj1FZZj1F6>    c                     t        | |       t        | |      \  } }t        j                  | |z
  dz  t        j                        S )a  
    Compute the mean-squared error between two images.

    Parameters
    ----------
    image0, image1 : ndarray
        Images.  Any dimensionality, must have same shape.

    Returns
    -------
    mse : float
        The mean-squared error (MSE) metric.

    Notes
    -----
    .. versionchanged:: 0.16
        This function was renamed from ``skimage.measure.compare_mse`` to
        ``skimage.metrics.mean_squared_error``.

    r   r   )r   r   r   meanfloat64)r   r   s     r   r	   r	      s<    * (/NFF77FVO)<<r   	euclidean)normalizationc                   t        | |       t        | |      \  } }|j                         }|dk(  r<t        j                  t        j
                  | | z  t        j                              }nH|dk(  r"| j                         | j                         z
  }n!|dk(  r| j                         }nt        d      t        j                  t        | |            |z  S )a0  
    Compute the normalized root mean-squared error (NRMSE) between two
    images.

    Parameters
    ----------
    image_true : ndarray
        Ground-truth image, same shape as im_test.
    image_test : ndarray
        Test image.
    normalization : {'euclidean', 'min-max', 'mean'}, optional
        Controls the normalization method to use in the denominator of the
        NRMSE.  There is no standard method of normalization across the
        literature [1]_.  The methods available here are as follows:

        - 'euclidean' : normalize by the averaged Euclidean norm of
          ``im_true``::

              NRMSE = RMSE * sqrt(N) / || im_true ||

          where || . || denotes the Frobenius norm and ``N = im_true.size``.
          This result is equivalent to::

              NRMSE = || im_true - im_test || / || im_true ||.

        - 'min-max'   : normalize by the intensity range of ``im_true``.
        - 'mean'      : normalize by the mean of ``im_true``

    Returns
    -------
    nrmse : float
        The NRMSE metric.

    Notes
    -----
    .. versionchanged:: 0.16
        This function was renamed from ``skimage.measure.compare_nrmse`` to
        ``skimage.metrics.normalized_root_mse``.

    References
    ----------
    .. [1] https://en.wikipedia.org/wiki/Root-mean-square_deviation

    r   r   zmin-maxr   zUnsupported norm_type)r   r   lowerr   sqrtr   r   maxmin
ValueErrorr	   )
image_true
image_testr   denoms       r   r
   r
   3   s    Z Z0'
J?J
 "'')M#j!8LM	)	# :>>#33	&	 !01177%j*=>FFr   )
data_rangec                   t        | |       || j                  |j                  k7  rt        d       t        | j                  j                     \  }}t        j                  |       t        j                  |       }}||kD  s||k  rt        d      |dk\  r|}n||z
  }t        | |      \  } }t        | |      }t        |      }dt        j                  |dz  |z        z  S )a   
    Compute the peak signal to noise ratio (PSNR) for an image.

    Parameters
    ----------
    image_true : ndarray
        Ground-truth image, same shape as im_test.
    image_test : ndarray
        Test image.
    data_range : int, optional
        The data range of the input image (distance between minimum and
        maximum possible values).  By default, this is estimated from the image
        data-type.

    Returns
    -------
    psnr : float
        The PSNR metric.

    Notes
    -----
    .. versionchanged:: 0.16
        This function was renamed from ``skimage.measure.compare_psnr`` to
        ``skimage.metrics.peak_signal_noise_ratio``.

    References
    ----------
    .. [1] https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio

    zFInputs have mismatched dtype.  Setting data_range based on image_true.zuimage_true has intensity values outside the range expected for its data type. Please manually specify the data_range.r   
   r   )r   r   r   r   typer   r!   r    r"   r   r	   floatlog10)r#   r$   r&   dmindmaxtrue_mintrue_maxerrs           r   r   r   p   s    > Z0z/// !!1!1!6!67
dVVJ/
1C(d?hoM  q=JJ'
J?J

Z
4Cz"J*a-3.///r   c                    t        d t        || j                        D              st        d| d| j                   d      t        || j                        D cg c]  \  }}d||z
  f }}}t	        j
                  | |dd      S c c}}w )ab  Pad an array with trailing zeros to a given target shape.

    Parameters
    ----------
    arr : ndarray
        The input array.
    shape : tuple
        The target shape.

    Returns
    -------
    padded : ndarray
        The padded array.

    Examples
    --------
    >>> _pad_to(np.ones((1, 1), dtype=int), (1, 3))
    array([[1, 0, 0]])
    c              3   ,   K   | ]  \  }}||k\    y w)N ).0sis      r   	<genexpr>z_pad_to.<locals>.<genexpr>   s     8$!QqAv8s   zTarget shape z# cannot be smaller than inputshape z along any axis.r   constant)	pad_widthmodeconstant_values)allzipshaper"   r   pad)arrr>   r5   r6   paddings        r   _pad_torB      s    ( 8#eSYY"788E7 #YYK/1
 	
 '*%&;<da1q5z<G<66#z1MM =s   B	d   )binsc                   | j                   |j                   k7  r&t        d| j                    d|j                    d      | j                  |j                  k7  rCt        j                  | j                  |j                        }t        | |      }t        ||      }n| |}}t        j                  t        j                  |d      t        j                  |d      g|d      \  }}t        t        j                  |d            }t        t        j                  |d	            }	t        t        j                  |d            }
||	z   |
z  S )
a  Compute the normalized mutual information (NMI).

    The normalized mutual information of :math:`A` and :math:`B` is given by::

    .. math::

        Y(A, B) = \frac{H(A) + H(B)}{H(A, B)}

    where :math:`H(X) := - \sum_{x \in X}{x \log x}` is the entropy.

    It was proposed to be useful in registering images by Colin Studholme and
    colleagues [1]_. It ranges from 1 (perfectly uncorrelated image values)
    to 2 (perfectly correlated image values, whether positively or negatively).

    Parameters
    ----------
    image0, image1 : ndarray
        Images to be compared. The two input images must have the same number
        of dimensions.
    bins : int or sequence of int, optional
        The number of bins along each axis of the joint histogram.

    Returns
    -------
    nmi : float
        The normalized mutual information between the two arrays, computed at
        the granularity given by ``bins``. Higher NMI implies more similar
        input images.

    Raises
    ------
    ValueError
        If the images don't have the same number of dimensions.

    Notes
    -----
    If the two input images are not the same shape, the smaller image is padded
    with zeros.

    References
    ----------
    .. [1] C. Studholme, D.L.G. Hill, & D.J. Hawkes (1999). An overlap
           invariant entropy measure of 3D medical image alignment.
           Pattern Recognition 32(1):71-86
           :DOI:`10.1016/S0031-3203(98)00091-0`
    z6NMI requires images of same number of dimensions. Got zD for `image0` and zD for `image1`.T)rD   densityr   )axis   )
ndimr"   r>   r   maximumrB   histogramddreshaper   sum)r   r   rD   	max_shapepadded0padded1hist	bin_edgesH0H1H01s              r   r   r      s   ^ {{fkk!;;-2{{m?,
 	

 ||v||#JJv||V\\:	&),&),!6nn	GR	 "**Wb"9:OD) 
1%	&B	1%	&B
"**T2&
'CGs?r   )numpyr   scipy.statsr   
util.dtyper   _shared.utilsr   r   r   __all__r   r	   r
   r   rB   r   r3   r   r   <module>r\      sQ      $ M M=4 BM :Gz CG 80vN: ;> Fr   