
    |h\3                     .   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j(                  d
      Zg dZ edd      D ]3  Z ee ee          e ee         dz         D ]  Zdedez   dez   f<    5  G d dee      Zy)    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                   H    e Zd ZdZ	 	 	 	 	 	 d
dZd Zd Zd Zd Zd Z	d Z
y	)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.]])

    c                     || _         || _        || _        || _        || _        || _        d | _        d | _        d | _        d | _	        d | _
        y )N)	downscalen_scalesn_keypointsfast_nfast_thresholdharris_k	keypointsscales	responsesorientationsdescriptors)selfr    r!   r"   r#   r$   r%   s          R/var/www/html/test/engine/venv/lib/python3.12/site-packages/skimage/feature/orb.py__init__zORB.__init__w   sU     # &,      c                 v    t        |      }t        t        || j                  dz
  | j                  d             S )Nr   )channel_axis)r   listr   r!   r    )r+   images     r,   _build_pyramidzORB._build_pyramid   s7    +E2t}}q($..t
 	
r.   c                    |j                   }t        || j                  | j                        }t	        |d      }t        |      dk(  rDt        j                  d|      t        j                  d|      t        j                  d|      fS t        |j                  |d      }||   }t        ||t              }t        |d	| j                  
      }||d d df   |d d df   f   }|||fS )Nr   )min_distancer   )r   r   dtype)r   r   distancek)methodr:   )r7   r	   r#   r$   r   lennpzerosr   shaper
   
OFAST_MASKr   r%   )	r+   octave_imager7   fast_responser&   maskr)   harris_responser(   s	            r,   _detect_octavezORB._detect_octave   s    ""#L$++t?R?RS Q?	y>Qu-U+U+  &l&8&8)bQdO	*<JO'SDMMR#IadOYq!t_$DE	,	11r.   c                    t        |d       | j                  |      }g }g }g }g }t        t        |            D ]  }t	        j
                  ||         }t	        j                  |      j                  dk  r n| j                  |      \  }	}
}|j                  |	| j                  |z  z         |j                  |
       |j                  t	        j                  |	j                  d   | j                  |z  |j                               |j                  |        t	        j                  |      }	t	        j                  |      }
t	        j                  |      }t	        j                  |      }|	j                  d   | j                   k  r|	| _        || _        |
| _        || _        y|j+                         ddd   d| j                    }|	|   | _        ||   | _        |
|   | _        ||   | _        y)zDetect oriented FAST keypoints along with the corresponding scale.

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

        r   r   r6   N)r   r3   ranger<   r=   ascontiguousarraysqueezendimrE   appendr    fullr?   r7   vstackhstackr"   r&   r'   r)   r(   argsort)r+   r2   pyramidkeypoints_listorientations_listscales_listresponses_listoctaverA   r&   r)   r(   r'   best_indicess                 r,   detectz
ORB.detect   s    	%%e,CL) 	-F//@Lzz,',,q0151D1D\1R.I|Y!!)dnnf.D"DE$$\2OOA&NNF*&,, !!),%	-( IIn-	yy!23;'IIn-	??1 0 00&DN DK ,D&DN %,,.tt45Gt7G7GHL&|4DN .DK ,\ :D&|4DNr.   c                     t        |j                  |d      }t        j                  ||   t        j                  dt
              }t        j                  ||   dd      }t        |||      }||fS )N   r8   C)r7   ordercopyF)r\   r]   )r   r?   r=   arrayintpr   r   )r+   rA   r&   r)   rC   r*   s         r,   _extract_octavezORB._extract_octave   sh    %l&8&8)bQHHdO277#<M
	 xxT 2#EJiFD  r.   c                    t        |d       | j                  |      }g }g }t        j                  |      t        j                  | j                        z  j                  t        j                        }t        t        |            D ]  }	||	k(  }
t        j                  |
      dkD  s!t        j                  ||	         }||
   }|| j                  |	z  z  }||
   }| j                  |||      \  }}|j                  |       |j                  |        t        j                  |      j                  t              | _        t        j"                  |      | _        y)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   r3   r=   logr    astyper_   rH   r<   sumrI   r`   rL   rN   viewboolr*   rO   mask_)r+   r2   r&   r'   r)   rQ   descriptors_list	mask_listoctavesrV   octave_maskrA   octave_keypointsoctave_orientationsr*   rC   s                   r,   extractzORB.extract   s5   ( 	%%e,	 66&>BFF4>>$::BB277KCL) 	'F!V+Kvvk"Q&!33GFOD#,[#9  DNNF$:: &2;&?#$($8$8 "24G%!T !''4  &!	'$ 99%56;;DAYYy)
r.   c                    t        |d       | j                  |      }g }g }g }g }g }t        t        |            D ]v  }t	        j
                  ||         }	t	        j                  |	      j                  dk  r n9| j                  |	      \  }
}}t        |
      dk(  rM|j                  |
       |j                  |       |j                  t	        j                  dt                     | j                  |	|
|      \  }}|
|   | j                  |z  z  }|j                  |       |j                  ||          |j                  ||          |j                  | j                  |z  t	        j                  |j                  d   t        j                         z         |j                  |       y t        |      dk(  rt#        d      t	        j$                  |      }
t	        j&                  |      }t	        j&                  |      }t	        j&                  |      }t	        j$                  |      j)                  t              }|
j                  d   | j*                  k  r$|
| _        || _        || _        || _        || _        y|j7                         ddd   d| j*                   }|
|   | _        ||   | _        ||   | _        ||   | _        ||   | _        y)zDetect 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      r6   znORB found no features. Try passing in an image containing greater intensity contrasts between adjacent pixels.NrG   )r   r3   rH   r<   r=   rI   rJ   rK   rE   rL   r>   rf   r`   r    onesr?   r_   RuntimeErrorrN   rO   re   r"   r&   r'   r)   r(   r*   rP   )r+   r2   rQ   rR   rU   rT   rS   rh   rV   rA   r&   r)   r(   r*   rC   scaled_keypointsr'   rW   s                     r,   detect_and_extractzORB.detect_and_extract"  s    	%%e,CL) 	1F//@Lzz,',,q0151D1D\1R.I|Y9~"%%i0%%i0 ''(FG $ 4 4i!K  )1GG!!"23!!)D/2$$\$%78&''*003277CD ##K07	1: {q G 
 IIn-	IIn-	;'yy!23ii 0166t<??1 0 00&DN DK ,D&DN*D %,,.tt45Gt7G7GHL&|4DN .DK ,\ :D&|4DN*<8Dr.   N)g333333?r   i  r   g{Gz?g{Gz?)__name__
__module____qualname____doc__r-   r3   rE   rX   r`   rn   rt    r.   r,   r   r      sC    [~  ,
2.65p	!1*fL9r.   r   )numpyr=   feature.utilr   r   r   r   cornerr	   r
   r   r   	transformr   _shared.utilsr   _shared.compatr   orb_cyr   r>   r@   
OFAST_UMAXrH   iabsjr   ry   r.   r,   <module>r      s      R Q ( $ .  RXXh
I
	sB 'AJs1v&&
3q6(:Q(>? '%&
2626>"''
U9/. U9r.   