
    0-Ph7                      x    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dS )    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/jupyter/venv/lib/python3.11/site-packages/skimage/metrics/simple_metrics.py
_as_floatsr      sL     'fl'CDDJZj111FZj11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	      sG    * (((//NFF7FVO)<<<<r   	euclidean)normalizationc                   t          | |           t          | |          \  } }|                                }|dk    r6t          j        t          j        | | z  t          j                            }nZ|dk    r*|                                 |                                 z
  }n*|dk    r|                                 }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00'
J??J
 "''))M##j!8LLLMM	)	#	#  :>>#3#33	&	 	 !!01117%j*==>>FFr   )
data_rangec                   t          | |           || j        |j        k    rt          d           t          | j        j                 \  }}t          j        |           t          j        |           }}||k    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

    NzFInputs 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00z///   !!1!67
dVJ//
1C1C(d??hooM   q==JJJ'
J??J

Z
4
4Cz""J*a-3.////r   c                     t          d t          || j                  D                       st          d| d| j         d          d t          || j                  D             }t	          j        | |dd          S )	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    V  d S )N .0sis      r   	<genexpr>z_pad_to.<locals>.<genexpr>   s*      88$!QqAv888888r   zTarget shape z# cannot be smaller than inputshape z along any axis.c                 "    g | ]\  }}d ||z
  fS )r   r3   r4   s      r   
<listcomp>z_pad_to.<locals>.<listcomp>   s$    <<<da1q5z<<<r   constantr   )	pad_widthmodeconstant_values)allzipshaper"   r   pad)arrrA   paddings      r   _pad_torE      s    ( 88#eSY"7"788888 
1E 1 1Y1 1 1
 
 	
 =<c%&;&;<<<G6#z1MMMMr   d   )binsc                n   | j         |j         k    r t          d| j          d|j          d          | j        |j        k    r@t          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)rG   densityr   )axis   )
ndimr"   rA   r   maximumrE   histogramddreshaper   sum)r   r   rG   	max_shapepadded0padded1hist	bin_edgesH0H1H01s              r   r   r      s>   ^ {fk!!,;, ,{, , ,
 
 	

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