9iSSKrSSKrSSKJr SSKrSSKJr SSKJ r J r SSK J r SSK JrJrJr SSKJr SS KJr S S KJr S S KJrJrJr S S KJr S SKJrJr S$SjrS%Sjr S&Sjr!S'Sjr"S(Sjr#Sr$Sr%Sr&Sr'S)Sjr(S$Sjr)S*Sjr*S+Sjr+S+Sjr,S,Sjr-S-Sjr.S SSSS\R^SS4\R^\R^S .S!jjr0S+S"jr1S#r2g).N)combinations_with_replacement)ndimage)spatialstats)gaussian)_supported_float_type safe_as_intwarn)integral_image) img_as_float)_hessian_matrix_det) _corner_fast_corner_moravec_corner_orientations)peak_local_max)_prepare_grayscale_input_2D_prepare_grayscale_input_nDc [UR5Vs/sHn[R"XXS9PM nnU$s snf)aCompute derivatives in axis directions using the Sobel operator. Parameters ---------- image : ndarray Input image. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. Returns ------- derivatives : list of ndarray Derivatives in each axis direction. )axismodecval)rangendimndisobel)imagerri derivativess V/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/skimage/feature/corner.py_compute_derivativesr"sD*AFejj@Q@Q1 %d6@Q  s;c US:XaURS:a [S5eUS;a[SUS35e[R"U5(d/[ U5n[ U5UR:wa [S5e[ U5n[XUS9nUS:Xa [U5n[US5VVs/sHupg[Xg-XUS 9PM nnnU$s snnf) aCompute structure tensor using sum of squared differences. The (2-dimensional) structure tensor A is defined as:: A = [Arr Arc] [Arc Acc] which is approximated by the weighted sum of squared differences in a local window around each pixel in the image. This formula can be extended to a larger number of dimensions (see [1]_). Parameters ---------- image : ndarray Input image. sigma : float or array-like of float, optional Standard deviation used for the Gaussian kernel, which is used as a weighting function for the local summation of squared differences. If sigma is an iterable, its length must be equal to `image.ndim` and each element is used for the Gaussian kernel applied along its respective axis. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. order : {'rc', 'xy'}, optional NOTE: 'xy' is only an option for 2D images, higher dimensions must always use 'rc' order. This parameter allows for the use of reverse or forward order of the image axes in gradient computation. 'rc' indicates the use of the first axis initially (Arr, Arc, Acc), whilst 'xy' indicates the usage of the last axis initially (Axx, Axy, Ayy). Returns ------- A_elems : list of ndarray Upper-diagonal elements of the structure tensor for each pixel in the input image. Examples -------- >>> from skimage.feature import structure_tensor >>> square = np.zeros((5, 5)) >>> square[2, 2] = 1 >>> Arr, Arc, Acc = structure_tensor(square, sigma=0.1, order='rc') >>> Acc array([[0., 0., 0., 0., 0.], [0., 1., 0., 1., 0.], [0., 4., 0., 4., 0.], [0., 1., 0., 1., 0.], [0., 0., 0., 0., 0.]]) See also -------- structure_tensor_eigenvalues References ---------- .. [1] https://en.wikipedia.org/wiki/Structure_tensor xyrz)Only "rc" order is supported for dim > 2.rcr$zorder z( is invalid. Must be either "rc" or "xy"z2sigma must have as many elements as image has axesrrsigmarr) r ValueErrornpisscalartuplelenrr"reversedrr) rr)rrorderr der0der1A_elemss r!structure_tensorr4.sz }aDEE L 6%(PQRR ;;u  e  u: #TU U ' .E&udCK }{+ 8 QGGJD E4@G  N s6Cc P^^[U5n[UR5nURUSS9nURS:aUS:Xa [ S5eUS;a[ SU35e[ R"U5(aU4UR-n[SU55(aS OS nS [R"S5- m[U4S jU55n[XrX6S 9n[R"[R 40UD6n URm[U4Sj[#T555n [#T5V s/sH o"X U S9PM n n [#T5n US:Xa [%U 5n ['U S5VVs/sHupU "XXS9PM nnnU$s sn fs snnf)aCompute the Hessian via convolutions with Gaussian derivatives. In 2D, the Hessian matrix is defined as: H = [Hrr Hrc] [Hrc Hcc] which is computed by convolving the image with the second derivatives of the Gaussian kernel in the respective r- and c-directions. The implementation here also supports n-dimensional data. Parameters ---------- image : ndarray Input image. sigma : float or sequence of float, optional Standard deviation used for the Gaussian kernel, which sets the amount of smoothing in terms of pixel-distances. It is advised to not choose a sigma much less than 1.0, otherwise aliasing artifacts may occur. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. order : {'rc', 'xy'}, optional This parameter allows for the use of reverse or forward order of the image axes in gradient computation. 'rc' indicates the use of the first axis initially (Hrr, Hrc, Hcc), whilst 'xy' indicates the usage of the last axis initially (Hxx, Hxy, Hyy) Returns ------- H_elems : list of ndarray Upper-diagonal elements of the hessian matrix for each pixel in the input image. In 2D, this will be a three element list containing [Hrr, Hrc, Hcc]. In nD, the list will contain ``(n**2 + n) / 2`` arrays. Fcopyrr$+order='xy' is only supported for 2D images.r%unrecognized order: c3*# UH oS:v M g7f)rN).0ss r! 0_hessian_matrix_with_gaussian..s-u!Ausdrc3.># UH nTU-v M g7f)Nr;)r<r=sq1_2s r!r>r?s2EqEs)r)rrtruncatec3R># UHnS/U-S/-S/TU- S- --v M g7f)rrNr;)r<drs r!r>r?s1MAA37aS=A3$(Q,#77s$'r0)r r dtypeastyperr*r+r,allmathsqrtr-dict functoolspartialrgaussian_filterrr/r)rr)rrr0 float_dtyperD sigma_scaled common_kwargs gaussian_ordersrF gradientsaxesax0ax1H_elemsrrCs @@r!_hessian_matrix_with_gaussianr[sP  E' 4K LL5L 1E zzA~%4-FGG L /w788 {{55::%-u---q3H  ! E2E22L|TUM!!#"5"5GGI ::D MtM MF>HC ). 4>  NI s FF"c [U5n[UR5nURUSS9nURS:aUS:Xa [ S5eUS;a[ SU35eUcSn[ S[SS 9 U(a [XX#US 9$[XX#S 9n[R"U5n[UR5n US:Xa [U 5n [U S5V V s/sHup[R"XU S 9PM n n n U $s sn n f) a Compute the Hessian matrix. In 2D, the Hessian matrix is defined as:: H = [Hrr Hrc] [Hrc Hcc] which is computed by convolving the image with the second derivatives of the Gaussian kernel in the respective r- and c-directions. The implementation here also supports n-dimensional data. Parameters ---------- image : ndarray Input image. sigma : float Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. order : {'rc', 'xy'}, optional For 2D images, this parameter allows for the use of reverse or forward order of the image axes in gradient computation. 'rc' indicates the use of the first axis initially (Hrr, Hrc, Hcc), whilst 'xy' indicates the usage of the last axis initially (Hxx, Hxy, Hyy). Images with higher dimension must always use 'rc' order. use_gaussian_derivatives : boolean, optional Indicates whether the Hessian is computed by convolving with Gaussian derivatives, or by a simple finite-difference operation. Returns ------- H_elems : list of ndarray Upper-diagonal elements of the hessian matrix for each pixel in the input image. In 2D, this will be a three element list containing [Hrr, Hrc, Hcc]. In nD, the list will contain ``(n**2 + n) / 2`` arrays. Notes ----- The distributive property of derivatives and convolutions allows us to restate the derivative of an image, I, smoothed with a Gaussian kernel, G, as the convolution of the image with the derivative of G. .. math:: \frac{\partial }{\partial x_i}(I * G) = I * \left( \frac{\partial }{\partial x_i} G \right) When ``use_gaussian_derivatives`` is ``True``, this property is used to compute the second order derivatives that make up the Hessian matrix. When ``use_gaussian_derivatives`` is ``False``, simple finite differences on a Gaussian-smoothed image are used instead. Examples -------- >>> from skimage.feature import hessian_matrix >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> Hrr, Hrc, Hcc = hessian_matrix(square, sigma=0.1, order='rc', ... use_gaussian_derivatives=False) >>> Hrc array([[ 0., 0., 0., 0., 0.], [ 0., 1., 0., -1., 0.], [ 0., 0., 0., 0., 0.], [ 0., -1., 0., 1., 0.], [ 0., 0., 0., 0., 0.]]) Fr6rr$r8r%r9zuse_gaussian_derivatives currently defaults to False, but will change to True in a future version. Please specify this argument explicitly to maintain the current behavior)category stacklevel)r)rrr0r(r)r r rHrIrr*r FutureWarningr[rr+gradientrr/r) rr)rrr0use_gaussian_derivativesrQgaussian_filteredrVrWrXrYrZs r!hessian_matrixrds"\  E' 4K LL5L 1E zzA~%4-FGG L /w788'#(   C#   , TE  !$J -.I  D }~6dA>>HC IN->  N s!#D TcH[U5n[UR5nURUSS9nURS:Xa1U(a*[ U5n[ R"[XA55$[[XSS95n[ RRU5$)aCompute the approximate Hessian Determinant over an image. The 2D approximate method uses box filters over integral images to compute the approximate Hessian Determinant. Parameters ---------- image : ndarray The image over which to compute the Hessian Determinant. sigma : float, optional Standard deviation of the Gaussian kernel used for the Hessian matrix. approximate : bool, optional If ``True`` and the image is 2D, use a much faster approximate computation. This argument has no effect on 3D and higher images. Returns ------- out : array The array of the Determinant of Hessians. References ---------- .. [1] Herbert Bay, Andreas Ess, Tinne Tuytelaars, Luc Van Gool, "SURF: Speeded Up Robust Features" ftp://ftp.vision.ee.ethz.ch/publications/articles/eth_biwi_00517.pdf Notes ----- For 2D images when ``approximate=True``, the running time of this method only depends on size of the image. It is independent of `sigma` as one would expect. The downside is that the result for `sigma` less than `3` is not accurate, i.e., not similar to the result obtained if someone computed the Hessian and took its determinant. Fr6r)rb) r r rHrIrr r+arrayr_symmetric_imagerdlinalgdet)rr) approximaterQintegralhessian_mat_arrays r!hessian_matrix_detrmUsH  E' 4K LL5L 1E zzQ;!%(xx+H<==, 5% H yy}}.//c[U5S:Xa~Uupn[R"S/URQ7UR5nX-S- USS&[R "US-X- S- S--5nUS==U- ss'US==U-ss'U$[ U5n[RRU5SSSS24n[[URS- 55n[R"XDRS- 4U-5$)aCompute eigenvalues from the upper-diagonal entries of a symmetric matrix. Parameters ---------- S_elems : list of ndarray The upper-diagonal elements of the matrix, as returned by `hessian_matrix` or `structure_tensor`. Returns ------- eigs : ndarray The eigenvalues of the matrix, in decreasing order. The eigenvalues are the leading dimension. That is, ``eigs[i, j, k]`` contains the ith-largest eigenvalue at position (j, k). rNrr.) r.r+emptyshaperHrLrgrheigvalshr-rr transpose)S_elemsM00M01M11eigshsqrtdetmatrices leading_axess r!_symmetric_compute_eigenvaluesr~s$ 7|q #xxSYY39/Q7736ci1_$::; Q8 Q8 #G,yy!!(+C2I6U499q=12 ||D99q="2\"ABBrnc&USn[R"URURUR4-USRS9n[ [ [UR5S55HunupEXUSXE4'XUSXT4'M U$)aConvert the upper-diagonal elements of a matrix to the full symmetric matrix. Parameters ---------- S_elems : list of array The upper-diagonal elements of the matrix, as returned by `hessian_matrix` or `structure_tensor`. Returns ------- image : array An array of shape ``(M, N[, ...], image.ndim, image.ndim)``, containing the matrix corresponding to each coordinate. rrHr.)r+zerosrsrrH enumeraterr)rvrsymmetric_imageidxrowcols r!rgrgs AJEhh uzz5::..gaj6F6FO%%eEJJ&7;Zc*1S &)0S &  rnc[U5$)a}Compute eigenvalues of structure tensor. Parameters ---------- A_elems : list of ndarray The upper-diagonal elements of the structure tensor, as returned by `structure_tensor`. Returns ------- ndarray The eigenvalues of the structure tensor, in decreasing order. The eigenvalues are the leading dimension. That is, the coordinate [i, j, k] corresponds to the ith-largest eigenvalue at position (j, k). Examples -------- >>> from skimage.feature import structure_tensor >>> from skimage.feature import structure_tensor_eigenvalues >>> square = np.zeros((5, 5)) >>> square[2, 2] = 1 >>> A_elems = structure_tensor(square, sigma=0.1, order='rc') >>> structure_tensor_eigenvalues(A_elems)[0] array([[0., 0., 0., 0., 0.], [0., 2., 4., 2., 0.], [0., 4., 0., 4., 0.], [0., 2., 4., 2., 0.], [0., 0., 0., 0., 0.]]) See also -------- structure_tensor r~)r3s r!structure_tensor_eigenvaluesrsD *' 22rnc[U5$)arCompute eigenvalues of Hessian matrix. Parameters ---------- H_elems : list of ndarray The upper-diagonal elements of the Hessian matrix, as returned by `hessian_matrix`. Returns ------- eigs : ndarray The eigenvalues of the Hessian matrix, in decreasing order. The eigenvalues are the leading dimension. That is, ``eigs[i, j, k]`` contains the ith-largest eigenvalue at position (j, k). Examples -------- >>> from skimage.feature import hessian_matrix, hessian_matrix_eigvals >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> H_elems = hessian_matrix(square, sigma=0.1, order='rc', ... use_gaussian_derivatives=False) >>> hessian_matrix_eigvals(H_elems)[0] array([[ 0., 0., 2., 0., 0.], [ 0., 1., 0., 1., 0.], [ 2., 0., -2., 0., 2.], [ 0., 1., 0., 1., 0.], [ 0., 0., 2., 0., 0.]]) r)rZs r!hessian_matrix_eigvalsrs< *' 22rnc [UUUUSSS9n[U5upV[R"SSS9 S[R- [R "Xe-Xe- - 5-sSSS5 $!,(df  g=f)aCompute the shape index. The shape index, as defined by Koenderink & van Doorn [1]_, is a single valued measure of local curvature, assuming the image as a 3D plane with intensities representing heights. It is derived from the eigenvalues of the Hessian, and its value ranges from -1 to 1 (and is undefined (=NaN) in *flat* regions), with following ranges representing following shapes: .. table:: Ranges of the shape index and corresponding shapes. =================== ============= Interval (s in ...) Shape =================== ============= [ -1, -7/8) Spherical cup [-7/8, -5/8) Through [-5/8, -3/8) Rut [-3/8, -1/8) Saddle rut [-1/8, +1/8) Saddle [+1/8, +3/8) Saddle ridge [+3/8, +5/8) Ridge [+5/8, +7/8) Dome [+7/8, +1] Spherical cap =================== ============= Parameters ---------- image : (M, N) ndarray Input image. sigma : float, optional Standard deviation used for the Gaussian kernel, which is used for smoothing the input data before Hessian eigen value calculation. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. Returns ------- s : ndarray Shape index References ---------- .. [1] Koenderink, J. J. & van Doorn, A. J., "Surface shape and curvature scales", Image and Vision Computing, 1992, 10, 557-564. :DOI:`10.1016/0262-8856(92)90076-F` Examples -------- >>> from skimage.feature import shape_index >>> square = np.zeros((5, 5)) >>> square[2, 2] = 4 >>> s = shape_index(square, sigma=0.1) >>> s array([[ nan, nan, -0.5, nan, nan], [ nan, -0. , nan, -0. , nan], [-0.5, nan, -1. , nan, -0.5], [ nan, -0. , nan, -0. , nan], [ nan, nan, -0.5, nan, nan]]) r&F)r)rrr0rbignore)divideinvalidg@N)rdrr+errstatepiarctan)rr)rrHl1l2s r! shape_indexr smD    !&  A$A &FB Hh 7bee ryy"'bg)>?? 8 7 7s 1A,, A:c,[UR5nURUSS9n[XUS9upE[XQUS9upg[XAUS9upXtS--XS---SU-U-U-- n US-US--n [R "XS9n U S:gn XX- X'U $)aGCompute Kitchen and Rosenfeld corner measure response image. The corner measure is calculated as follows:: (imxx * imy**2 + imyy * imx**2 - 2 * imxy * imx * imy) / (imx**2 + imy**2) Where imx and imy are the first and imxx, imxy, imyy the second derivatives. Parameters ---------- image : (M, N) ndarray Input image. mode : {'constant', 'reflect', 'wrap', 'nearest', 'mirror'}, optional How to handle values outside the image borders. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. Returns ------- response : ndarray Kitchen and Rosenfeld response image. References ---------- .. [1] Kitchen, L., & Rosenfeld, A. (1982). Gray-level corner detection. Pattern recognition letters, 1(2), 95-102. :DOI:`10.1016/0167-8655(82)90020-4` Fr6r'rrr)r rHrIr"r+ zeros_like)rrrrQimyimximxyimxximyyimyx numerator denominatorresponsemasks r!corner_kitchen_rosenfeldr[sB( 4K LL5L 1E#E4@HC%c4@JD%c4@JDAv Av -D30DDIq&36/K}}U6H ! D_{'88HN Ornct[XSS9upVnXW-US-- nXW-n US:Xa XU S--- n U $SU-X-- n U $)aCompute Harris corner measure response image. This corner detector uses information from the auto-correlation matrix A:: A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy] Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as:: det(A) - k * trace(A)**2 or:: 2 * det(A) / (trace(A) + eps) Parameters ---------- image : (M, N) ndarray Input image. method : {'k', 'eps'}, optional Method to compute the response image from the auto-correlation matrix. k : float, optional Sensitivity factor to separate corners from edges, typically in range `[0, 0.2]`. Small values of k result in detection of sharp corners. eps : float, optional Normalisation factor (Noble's corner measure). sigma : float, optional Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix. Returns ------- response : ndarray Harris response image. References ---------- .. [1] https://en.wikipedia.org/wiki/Corner_detection Examples -------- >>> from skimage.feature import corner_harris, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_harris(square), min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]]) r&rGrk)r4) rmethodrepsr)ArrArcAccdetAtraceArs r! corner_harrisrscB%U>MCc 9sAv D YF }fai-' Ot8v|, Orncx[XSS9up#nX$-[R"X$- S-SUS---5- S- nU$)aCompute Shi-Tomasi (Kanade-Tomasi) corner measure response image. This corner detector uses information from the auto-correlation matrix A:: A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy] Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as the smaller eigenvalue of A:: ((Axx + Ayy) - sqrt((Axx - Ayy)**2 + 4 * Axy**2)) / 2 Parameters ---------- image : (M, N) ndarray Input image. sigma : float, optional Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix. Returns ------- response : ndarray Shi-Tomasi response image. References ---------- .. [1] https://en.wikipedia.org/wiki/Corner_detection Examples -------- >>> from skimage.feature import corner_shi_tomasi, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_shi_tomasi(square), min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]]) r&rGr)r4r+rL)rr)rrrrs r!corner_shi_tomasirsJl%U>MCcbggsyQ&6S!V&CDDIH Ornc[XSS9up#nX$-US-- nX$-n[R"XRS9n[R"U5nUS:gn XYXi- Xy'SXY-XiS-- X'Xx4$)uCompute Foerstner corner measure response image. This corner detector uses information from the auto-correlation matrix A:: A = [(imx**2) (imx*imy)] = [Axx Axy] [(imx*imy) (imy**2)] [Axy Ayy] Where imx and imy are first derivatives, averaged with a gaussian filter. The corner measure is then defined as:: w = det(A) / trace(A) (size of error ellipse) q = 4 * det(A) / trace(A)**2 (roundness of error ellipse) Parameters ---------- image : (M, N) ndarray Input image. sigma : float, optional Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix. Returns ------- w : ndarray Error ellipse sizes. q : ndarray Roundness of error ellipse. References ---------- .. [1] Förstner, W., & Gülch, E. (1987, June). A fast operator for detection and precise location of distinct points, corners and centres of circular features. In Proc. ISPRS intercommission conference on fast processing of photogrammetric data (pp. 281-305). https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf .. [2] https://en.wikipedia.org/wiki/Corner_detection Examples -------- >>> from skimage.feature import corner_foerstner, corner_peaks >>> square = np.zeros([10, 10]) >>> square[2:8, 2:8] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> w, q = corner_foerstner(square) >>> accuracy_thresh = 0.5 >>> roundness_thresh = 0.3 >>> foerstner = (q > roundness_thresh) * (w > accuracy_thresh) * w >>> corner_peaks(foerstner, min_distance=1) array([[2, 2], [2, 7], [7, 2], [7, 7]]) r&rGrrrr)r4r+rrH) rr)rrrrrwqrs r!corner_foerstnerrsD%U>MCc 9sAv D YF e::.A aA Q;Dj6<'AG$*nv|q00AG 4Krnc`[U5n[R"U5n[XU5nU$)aExtract FAST corners for a given image. Parameters ---------- image : (M, N) ndarray Input image. n : int, optional Minimum number of consecutive pixels out of 16 pixels on the circle that should all be either brighter or darker w.r.t testpixel. 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. threshold : float, optional Threshold used in deciding 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. Returns ------- response : ndarray FAST corner response image. References ---------- .. [1] Rosten, E., & Drummond, T. (2006, May). Machine learning for high-speed corner detection. In European conference on computer vision (pp. 430-443). Springer, Berlin, Heidelberg. :DOI:`10.1007/11744023_34` http://www.edwardrosten.com/work/rosten_2006_machine.pdf .. [2] Wikipedia, "Features from accelerated segment test", https://en.wikipedia.org/wiki/Features_from_accelerated_segment_test Examples -------- >>> from skimage.feature import corner_fast, corner_peaks >>> square = np.zeros((12, 12)) >>> square[3:9, 3:9] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corner_peaks(corner_fast(square, 9), min_distance=1) array([[3, 3], [3, 8], [8, 3], [8, 8]]) )rr+ascontiguousarrayr)rn thresholdrs r! corner_fastrps0t ( .E   'EEi0H Ornc US- S-n[UR5nURUSS9n[R"XSSS9n[ X-5n[R "SUS 9n[R "SUS 9n[R "S US 9n[R "S US 9n US-S- n [RRSU- X5n [RRX:U 5n [RU*US-2U*US-24up[R"XS 9n[U5GHCununnUU- S- nUU-S-nUU- S- nUU-S-nUUU2UU24n[USSS 9unnUU-SS 2SS 24nUU-SS 2SS 24nUU-SS 2SS 24n[R"U5n[R"U5n[R"U5n[R"UU-5n [R"UU -5n![R"UU-5n"[R"UU -5n#[R"UU-5n$[R"UU -5n%UUS 'U*=US'US'UUS'UUS 'U=US'US'UUS'U!U"- U$U#- 4USS&U%U"-U U#-4U SS&[RR!Xh5n&[RR!Xy5n'U U&S- n(UU&S- n)U U'S- n*UU'S- n+U)U)-n,U)U(-n-U(U(-n.U+U+-n/U+U*-n0U*U*-n1[R"UU.-SU-U--- UU,--5n2[R"UU1-SU-U0--UU/--5n3U2[R&"S5:a+U3[R&"S5:a[R$n4OU2S:Xa[R(n4OU3U2- n4[+U4U :5[+U4U :5- n5U5S :XaUU&S-UU&S-4UUSS24'GMU5S:Xa*[R$[R$4UUSS24'GM#U5S:XdGM,UU'S-UU'S-4UUSS24'GMF X-nU$![RR"a, [R$[R$4UUSS24'GMf=f)uDetermine subpixel position of corners. A statistical test decides whether the corner is defined as the intersection of two edges or a single peak. Depending on the classification result, the subpixel corner location is determined based on the local covariance of the grey-values. If the significance level for either statistical test is not sufficient, the corner cannot be classified, and the output subpixel position is set to NaN. Parameters ---------- image : (M, N) ndarray Input image. corners : (K, 2) ndarray Corner coordinates `(row, col)`. window_size : int, optional Search window size for subpixel estimation. alpha : float, optional Significance level for corner classification. Returns ------- positions : (K, 2) ndarray Subpixel corner positions. NaN for "not classified" corners. References ---------- .. [1] Förstner, W., & Gülch, E. (1987, June). A fast operator for detection and precise location of distinct points, corners and centres of circular features. In Proc. ISPRS intercommission conference on fast processing of photogrammetric data (pp. 281-305). https://cseweb.ucsd.edu/classes/sp02/cse252/foerstner/foerstner.pdf .. [2] https://en.wikipedia.org/wiki/Corner_detection Examples -------- >>> from skimage.feature import corner_harris, corner_peaks, corner_subpix >>> img = np.zeros((10, 10)) >>> img[:5, :5] = 1 >>> img[5:, 5:] = 1 >>> img.astype(int) array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]) >>> coords = corner_peaks(corner_harris(img), min_distance=2) >>> coords_subpix = corner_subpix(img, coords, window_size=7) >>> coords_subpix array([[4.5, 4.5]]) rrFr6constantr) pad_widthrconstant_values)rrr)rr'rq)rr)rr)rr)rrN)r rHrIr+padr rrfisfmgridrrr"sumrhsolve LinAlgErrornanspacinginfint)6rcorners window_sizealphawextrQN_dotN_edgeb_dotb_edge redundancy t_crit_dot t_crit_edgeyxcorners_subpixry0x0minymaxyminxmaxxwindowwinywinx winx_winx winx_winy winy_winyAxxAxyAyybxx_xbxx_ybxy_xbxy_ybyy_xbyy_yest_dotest_edgery_dotrx_dotry_edgerx_edgerxx_dotrxy_dotryy_dotrxx_edgerxy_edgeryy_edgevar_dotvar_edget corner_classs6 r! corner_subpixrsx !O !D' 4K LL5L 1E FF5z1 ME'.)G HHV; /E XXfK 0F HHT -E XXd+ .Fa!#JQY ?J''++eN ) 8BDy1}Dy1}Dy1}Dy1}tDy$t)+,)&zJ dD[!B$"*- D[!B$"*- D[!B$"*- ffYffYffYy1}%y1}%y1}%y1}%y1}%y1}%d %(D(d eDkd t &))t vd|t 5=%%-/aEM55=0q  iiooe3Gyyv6HWQZWQZhqk/hqk/6/6/6/W$W$W$&&  !i-'"9 9IR R  RZZ] "x"**Q-'?A \A7"A1{?+c!j..AA 2 #% ?BO#CN1a4 Q #%66266>N1a4 Q #% #3R(1+5E#EN1a4 q*vN ayy$$ #%66266>N1a4  s;>RAS  S )num_peaks_per_labelp_normc  0[R"U5(aSn[UUUUU[RUUU S9 n [ U 5(a[ R "U 5n [5n [U 5H>upX;dM U RXU S9nURU5 U RU5 M@ [R"U [U 5SS9SUn U(aU $[R"U[S9nSU[U R 5'U$)aFind peaks in corner measure response image. This differs from `skimage.feature.peak_local_max` in that it suppresses multiple connected peaks with the same accumulator value. Parameters ---------- image : (M, N) ndarray Input image. min_distance : int, optional The minimal allowed distance separating peaks. * : * See :py:meth:`skimage.feature.peak_local_max`. p_norm : float Which Minkowski p-norm to use. Should be in the range [1, inf]. A finite large p may cause a ValueError if overflow can occur. ``inf`` corresponds to the Chebyshev distance and 2 to the Euclidean distance. Returns ------- output : ndarray or ndarray of bools * If `indices = True` : (row, column, ...) coordinates of peaks. * If `indices = False` : Boolean array shaped like `image`, with peaks represented by True values. See also -------- skimage.feature.peak_local_max Notes ----- .. versionchanged:: 0.18 The default value of `threshold_rel` has changed to None, which corresponds to letting `skimage.feature.peak_local_max` decide on the default. This is equivalent to `threshold_rel=0`. The `num_peaks` limit is applied before suppression of connected peaks. To limit the number of peaks after suppression, set `num_peaks=np.inf` and post-process the output of this function. Examples -------- >>> from skimage.feature import peak_local_max >>> response = np.zeros((5, 5)) >>> response[2:4, 2:4] = 1 >>> response array([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 1., 1., 0.], [0., 0., 1., 1., 0.], [0., 0., 0., 0., 0.]]) >>> peak_local_max(response) array([[2, 2], [2, 3], [3, 2], [3, 3]]) >>> corner_peaks(response) array([[2, 2]]) N) min_distance threshold_abs threshold_relexclude_border num_peaks footprintlabelsr)rprr_rT)r+isinfrrr.rcKDTreesetrquery_ball_pointremoveupdatedeleter-rboolT)rrrrrindicesrrrrrcoordstreerejected_peaks_indicesrpoint candidatespeakss r! corner_peaksrfsX xx   !##%&&/ F 6{{v&!$#F+JC0!225F2S !!#&&--j9 ,65)?#@qI*9U MM%t ,E!E%/ Lrnc[U5n[UR5nURUSS9n[ [ R "U5U5$)aCompute Moravec corner measure response image. This is one of the simplest corner detectors and is comparatively fast but has several limitations (e.g. not rotation invariant). Parameters ---------- image : (M, N) ndarray Input image. window_size : int, optional Window size. Returns ------- response : ndarray Moravec response image. References ---------- .. [1] https://en.wikipedia.org/wiki/Corner_detection Examples -------- >>> from skimage.feature import corner_moravec >>> square = np.zeros([7, 7]) >>> square[3, 3] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) >>> corner_moravec(square).astype(int) array([[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 2, 1, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) Fr6)r r rHrIrr+r)rrrQs r!corner_moravecrsGX  E' 4K LL5L 1E 2//6 DDrnc0[U5n[XU5$)a*Compute the orientation of corners. The orientation of corners is computed using the first order central moment i.e. the center of mass approach. The corner orientation is the angle of the vector from the corner coordinate to the intensity centroid in the local neighborhood around the corner calculated using first order central moment. Parameters ---------- image : (M, N) array Input grayscale image. corners : (K, 2) array Corner coordinates as ``(row, col)``. mask : 2D array Mask defining the local neighborhood of the corner used for the calculation of the central moment. Returns ------- orientations : (K, 1) array Orientations of corners in the range [-pi, pi]. 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 .. [2] Paul L. Rosin, "Measuring Corner Properties" http://users.cs.cf.ac.uk/Paul.Rosin/corner2.pdf Examples -------- >>> from skimage.morphology import octagon >>> from skimage.feature import (corner_fast, corner_peaks, ... corner_orientations) >>> square = np.zeros((12, 12)) >>> square[3:9, 3:9] = 1 >>> square.astype(int) array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> corners = corner_peaks(corner_fast(square, 9), min_distance=1) >>> corners array([[3, 3], [3, 8], [8, 3], [8, 8]]) >>> orientations = corner_orientations(square, corners, octagon(3, 2)) >>> np.rad2deg(orientations) array([ 45., 135., -45., -135.]) )rr)rrrs r!corner_orientationsr s~ ( .E  55rn)rr)rrrr&)rreflectrr&)rrrr&N)rT)rrr)rg?gư>r)r) g333333?) gGz?)3rNrK itertoolsrnumpyr+scipyrrrr_shared.filtersr _shared.utilsr r r transformr utilr _hessian_det_appxr corner_cyrrrpeakrrrr"r4r[rdrmr~rgrrrrrrrrrrrrrr;rnr!r+s 3 &DD&2JJ J6UpXxSWqh.0bCD8"3J3BN@b0fM`;|Qh>Brn ff p 66pf/Ed@6rn