o
    Õj\3  ã                   @   sÚ   d dl ZddlmZmZmZmZ ddlmZm	Z	m
Z
mZ ddlmZ ddlmZ ddlmZ dd	lmZ e d
¡Zg d¢ZeddƒD ]Zeeeeƒ  eeeƒ d ƒD ]Zdede de f< qTqBG dd„ deeƒZdS )é    Né   )ÚFeatureDetectorÚDescriptorExtractorÚ_mask_border_keypointsÚ_prepare_grayscale_input_2Dé   )Úcorner_fastÚcorner_orientationsÚcorner_peaksÚcorner_harris)Úpyramid_gaussian)Úcheck_nD)ÚNP_COPY_IF_NEEDED)Ú	_orb_loop)é   r   )é   r   r   r   é   r   r   é   r   é   é   é
   é	   é   é   é   iñÿÿÿé   r   c                   @   sV   e Zd ZdZ						ddd	„Zd
d„ Zdd„ Zdd„ Zdd„ Zdd„ Z	dd„ Z
dS )ÚORBa  Oriented FAST and rotated BRIEF feature detector and binary descriptor
    extractor.

    Parameters
    ----------
    n_keypoints : int, optional
        Number of keypoints to be returned. The function will return the best
        `n_keypoints` according to the Harris corner response if more than
        `n_keypoints` are detected. If not, then all the detected keypoints
        are returned.
    fast_n : int, optional
        The `n` parameter in `skimage.feature.corner_fast`. Minimum number of
        consecutive pixels out of 16 pixels on the circle that should all be
        either brighter or darker w.r.t test-pixel. A point c on the circle is
        darker w.r.t test pixel p if ``Ic < Ip - threshold`` and brighter if
        ``Ic > Ip + threshold``. Also stands for the n in ``FAST-n`` corner
        detector.
    fast_threshold : float, optional
        The ``threshold`` parameter in ``feature.corner_fast``. Threshold used
        to decide whether the pixels on the circle are brighter, darker or
        similar w.r.t. the test pixel. Decrease the threshold when more
        corners are desired and vice-versa.
    harris_k : float, optional
        The `k` parameter in `skimage.feature.corner_harris`. Sensitivity
        factor to separate corners from edges, typically in range ``[0, 0.2]``.
        Small values of `k` result in detection of sharp corners.
    downscale : float, optional
        Downscale factor for the image pyramid. Default value 1.2 is chosen so
        that there are more dense scales which enable robust scale invariance
        for a subsequent feature description.
    n_scales : int, optional
        Maximum number of scales from the bottom of the image pyramid to
        extract the features from.

    Attributes
    ----------
    keypoints : (N, 2) array
        Keypoint coordinates as ``(row, col)``.
    scales : (N,) array
        Corresponding scales.
    orientations : (N,) array
        Corresponding orientations in radians.
    responses : (N,) array
        Corresponding Harris corner responses.
    descriptors : (Q, `descriptor_size`) array of dtype bool
        2D array of binary descriptors of size `descriptor_size` for Q
        keypoints after filtering out border keypoints with value at an
        index ``(i, j)`` either being ``True`` or ``False`` representing
        the outcome of the intensity comparison for i-th keypoint on j-th
        decision pixel-pair. It is ``Q == np.sum(mask)``.

    References
    ----------
    .. [1] Ethan Rublee, Vincent Rabaud, Kurt Konolige and Gary Bradski
          "ORB: An efficient alternative to SIFT and SURF"
          http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf

    Examples
    --------
    >>> from skimage.feature import ORB, match_descriptors
    >>> img1 = np.zeros((100, 100))
    >>> img2 = np.zeros_like(img1)
    >>> rng = np.random.default_rng(19481137)  # do not copy this value
    >>> square = rng.random((20, 20))
    >>> img1[40:60, 40:60] = square
    >>> img2[53:73, 53:73] = square
    >>> detector_extractor1 = ORB(n_keypoints=5)
    >>> detector_extractor2 = ORB(n_keypoints=5)
    >>> detector_extractor1.detect_and_extract(img1)
    >>> detector_extractor2.detect_and_extract(img2)
    >>> matches = match_descriptors(detector_extractor1.descriptors,
    ...                             detector_extractor2.descriptors)
    >>> matches
    array([[0, 0],
           [1, 1],
           [2, 2],
           [3, 4],
           [4, 3]])
    >>> detector_extractor1.keypoints[matches[:, 0]]
    array([[59. , 59. ],
           [40. , 40. ],
           [57. , 40. ],
           [46. , 58. ],
           [58.8, 58.8]])
    >>> detector_extractor2.keypoints[matches[:, 1]]
    array([[72., 72.],
           [53., 53.],
           [70., 53.],
           [59., 71.],
           [72., 72.]])

    ç333333ó?r   éô  r   ç{®Gáz´?ç{®Gáz¤?c                 C   sF   || _ || _|| _|| _|| _|| _d | _d | _d | _d | _	d | _
d S )N)Ú	downscaleÚn_scalesÚn_keypointsÚfast_nÚfast_thresholdÚharris_kÚ	keypointsÚscalesÚ	responsesÚorientationsÚdescriptors)Úselfr!   r"   r#   r$   r%   r&   © r-   úT/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/skimage/feature/orb.pyÚ__init__w   s   	
zORB.__init__c                 C   s$   t |ƒ}tt|| jd | jd dƒS )Nr   )Zchannel_axis)r   Úlistr   r"   r!   )r,   Úimager-   r-   r.   Ú_build_pyramid   s   ÿÿzORB._build_pyramidc           	      C   s¸   |j }t|| j| jƒ}t|dd}t|ƒdkr+tjd|dtjd|dtjd|dfS t|j	|dd}|| }t
||tƒ}t|d	| jd
}||d d …df |d d …df f }|||fS )Nr   )Zmin_distancer   )r   r   ©Údtype)r   r   ©ZdistanceÚk)Úmethodr6   )r4   r   r$   r%   r
   ÚlenÚnpÚzerosr   Úshaper	   Ú
OFAST_MASKr   r&   )	r,   Úoctave_imager4   Zfast_responser'   Úmaskr*   Zharris_responser)   r-   r-   r.   Ú_detect_octave•   s   ý$
zORB._detect_octavec                 C   sP  t |dƒ |  |¡}g }g }g }g }tt|ƒƒD ]A}t || ¡}t |¡jdk r+ n/|  |¡\}	}
}| 	|	| j
|  ¡ | 	|
¡ | 	tj|	jd | j
| |jd¡ | 	|¡ qt |¡}	t |¡}
t |¡}t |¡}|	jd | jk r„|	| _|| _|
| _|| _dS | ¡ ddd… d| j… }|	| | _|| | _|
| | _|| | _dS )z¥Detect oriented FAST keypoints along with the corresponding scale.

        Parameters
        ----------
        image : 2D array
            Input image.

        r   r   r3   Néÿÿÿÿ)r   r2   Úranger8   r9   ÚascontiguousarrayÚsqueezeÚndimr?   Úappendr!   Úfullr;   r4   ÚvstackÚhstackr#   r'   r(   r*   r)   Úargsort)r,   r1   ÚpyramidÚkeypoints_listÚorientations_listÚscales_listÚresponses_listÚoctaver=   r'   r*   r)   r(   Úbest_indicesr-   r-   r.   Údetect¬   sF   
	

ýÿ







z
ORB.detectc                 C   sP   t |j|dd}tj|| tjdtd}tj|| ddd}t|||ƒ}||fS )Né   r5   ÚC)r4   ÚorderÚcopyF)rT   rU   )r   r;   r9   ÚarrayÚintpr   r   )r,   r=   r'   r*   r>   r+   r-   r-   r.   Ú_extract_octaveä   s   ÿzORB._extract_octavec                 C   sÖ   t |dƒ |  |¡}g }g }t |¡t | j¡  tj¡}tt|ƒƒD ]6}	||	k}
t 	|
¡dkrYt 
||	 ¡}||
 }|| j|	  }||
 }|  |||¡\}}| |¡ | |¡ q#t |¡ t¡| _t |¡| _dS )a  Extract rBRIEF binary descriptors for given keypoints in image.

        Note that the keypoints must be extracted using the same `downscale`
        and `n_scales` parameters. Additionally, if you want to extract both
        keypoints and descriptors you should use the faster
        `detect_and_extract`.

        Parameters
        ----------
        image : 2D array
            Input image.
        keypoints : (N, 2) array
            Keypoint coordinates as ``(row, col)``.
        scales : (N,) array
            Corresponding scales.
        orientations : (N,) array
            Corresponding orientations in radians.

        r   r   N)r   r2   r9   Úlogr!   ZastyperW   rA   r8   ÚsumrB   rX   rE   rG   ÚviewÚboolr+   rH   Zmask_)r,   r1   r'   r(   r*   rJ   Údescriptors_listZ	mask_listZoctavesrO   Zoctave_maskr=   Zoctave_keypointsZoctave_orientationsr+   r>   r-   r-   r.   Úextractï   s(   

ÿ

€zORB.extractc                 C   sì  t |dƒ |  |¡}g }g }g }g }g }tt|ƒƒD ]s}t || ¡}	t |	¡jdk r- na|  |	¡\}
}}t|
ƒdkrP| 	|
¡ | 	|¡ | 	tj
dtd¡ q|  |	|
|¡\}}|
| | j|  }| 	|¡ | 	|| ¡ | 	|| ¡ | 	| j| tj|jd tjd ¡ | 	|¡ qt|ƒdkr˜tdƒ‚t |¡}
t |¡}t |¡}t |¡}t |¡ t¡}|
jd | jk rÍ|
| _|| _|| _|| _|| _dS | ¡ ddd… d| j… }|
| | _|| | _|| | _|| | _|| | _dS )zûDetect oriented FAST keypoints and extract rBRIEF descriptors.

        Note that this is faster than first calling `detect` and then
        `extract`.

        Parameters
        ----------
        image : 2D array
            Input image.

        r   r   )r   é   r3   znORB found no features. Try passing in an image containing greater intensity contrasts between adjacent pixels.Nr@   )r   r2   rA   r8   r9   rB   rC   rD   r?   rE   r:   r\   rX   r!   Zonesr;   rW   ÚRuntimeErrorrG   rH   r[   r#   r'   r(   r*   r)   r+   rI   )r,   r1   rJ   rK   rN   rM   rL   r]   rO   r=   r'   r*   r)   r+   r>   Zscaled_keypointsr(   rP   r-   r-   r.   Údetect_and_extract"  sf   



ÿ
ÿÿÿ








zORB.detect_and_extractN)r   r   r   r   r   r    )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r/   r2   r?   rQ   rX   r^   ra   r-   r-   r-   r.   r      s    _
ù83r   )Únumpyr9   Zfeature.utilr   r   r   r   Zcornerr   r	   r
   r   Ú	transformr   Z_shared.utilsr   Z_shared.compatr   Zorb_cyr   r:   r<   Z
OFAST_UMAXrA   ÚiÚabsÚjr   r-   r-   r-   r.   Ú<module>   s    
$ÿ