9i=SSKrSSKJr SSKJrJrJr SSKJr SSS\R4Sjr SS jr SS jr SS jrSS jrSSS\R\RS 4SjrSrg)N)cKDTree) _hough_circle_hough_ellipse _hough_line)_probabilistic_hough_line cSSKJn [X@RS5nU"UUUUUS9upn U RS:a XU X*4$U[ R "/5[ R "/54$)ajReturn peaks in a straight line Hough transform. Identifies most prominent lines separated by a certain angle and distance in a Hough transform. Non-maximum suppression with different sizes is applied separately in the first (distances) and second (angles) dimension of the Hough space to identify peaks. Parameters ---------- hspace : ndarray, shape (M, N) Hough space returned by the `hough_line` function. angles : array, shape (N,) Angles returned by the `hough_line` function. Assumed to be continuous. (`angles[-1] - angles[0] == PI`). dists : array, shape (M,) Distances returned by the `hough_line` function. min_distance : int, optional Minimum distance separating lines (maximum filter size for first dimension of hough space). min_angle : int, optional Minimum angle separating lines (maximum filter size for second dimension of hough space). threshold : float, optional Minimum intensity of peaks. Default is `0.5 * max(hspace)`. num_peaks : int, optional Maximum number of peaks. When the number of peaks exceeds `num_peaks`, return `num_peaks` coordinates based on peak intensity. Returns ------- accum, angles, dists : tuple of array Peak values in Hough space, angles and distances. Examples -------- >>> from skimage.transform import hough_line, hough_line_peaks >>> from skimage.draw import line >>> img = np.zeros((15, 15), dtype=bool) >>> rr, cc = line(0, 0, 14, 14) >>> img[rr, cc] = 1 >>> rr, cc = line(0, 14, 14, 0) >>> img[cc, rr] = 1 >>> hspace, angles, dists = hough_line(img) >>> hspace, angles, dists = hough_line_peaks(hspace, angles, dists) >>> len(angles) 2 _prominent_peaksr min_xdistance min_ydistance threshold num_peaksr) feature.peakrminshapesizenparray) hspaceanglesdists min_distance min_anglerrrhads a/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/skimage/transform/hough_transform.pyhough_line_peaksr#srr0I||A/I" GA! vvz!9eh''288B<"..Fc[R"[R"U55n[XR [R 5X#S9$)adPerform a circular Hough transform. Parameters ---------- image : ndarray, shape (M, N) Input image with nonzero values representing edges. radius : scalar or sequence of scalars Radii at which to compute the Hough transform. Floats are converted to integers. normalize : boolean, optional Normalize the accumulator with the number of pixels used to draw the radius. full_output : boolean, optional Extend the output size by twice the largest radius in order to detect centers outside the input picture. Returns ------- H : ndarray, shape (radius index, M + 2R, N + 2R) Hough transform accumulator for each radius. R designates the larger radius if full_output is True. Otherwise, R = 0. Examples -------- >>> from skimage.transform import hough_circle >>> from skimage.draw import circle_perimeter >>> img = np.zeros((100, 100), dtype=bool) >>> rr, cc = circle_perimeter(25, 35, 23) >>> img[rr, cc] = 1 >>> try_radii = np.arange(5, 50) >>> res = hough_circle(img, try_radii) >>> ridx, r, c = np.unravel_index(np.argmax(res), res.shape) >>> r, c, try_radii[ridx] (25, 35, 23) ) normalize full_output)r atleast_1dasarrayrastypeintp)imageradiusr&r's r" hough_circler.Qs;N]]2::f- .F  }}RWW% r$c[UUUUUS9$)aPerform an elliptical Hough transform. Parameters ---------- image : (M, N) ndarray Input image with nonzero values representing edges. threshold : int, optional Accumulator threshold value. A lower value will return more ellipses. accuracy : double, optional Bin size on the minor axis used in the accumulator. A higher value will return more ellipses, but lead to a less precise estimation of the minor axis lengths. min_size : int, optional Minimal major axis length. max_size : int, optional Maximal minor axis length. If None, the value is set to half of the smaller image dimension. Returns ------- result : ndarray with fields [(accumulator, yc, xc, a, b, orientation)]. Where ``(yc, xc)`` is the center, ``(a, b)`` the major and minor axes, respectively. The `orientation` value follows the `skimage.draw.ellipse_perimeter` convention. Examples -------- >>> from skimage.transform import hough_ellipse >>> from skimage.draw import ellipse_perimeter >>> img = np.zeros((25, 25), dtype=np.uint8) >>> rr, cc = ellipse_perimeter(10, 10, 6, 8) >>> img[cc, rr] = 1 >>> result = hough_ellipse(img, threshold=8) >>> result.tolist() [(10, 10.0, 10.0, 8.0, 6.0, 0.0)] Notes ----- Potential ellipses in the image are characterized by their major and minor axis lengths. For any pair of nonzero pixels in the image that are at least half of `min_size` apart, an accumulator keeps track of the minor axis lengths of potential ellipses formed with all the other nonzero pixels. If any bin (with `bin_size = accuracy * accuracy`) in the histogram of those accumulated minor axis lengths is above `threshold`, the corresponding ellipse is added to the results. A higher `accuracy` will therefore lead to more ellipses being found in the image, at the cost of a less precise estimation of the minor axis length. References ---------- .. [1] Xie, Yonghong, and Qiang Ji. "A new efficient ellipse detection method." Pattern Recognition, 2002. Proceedings. 16th International Conference on. Vol. 2. IEEE, 2002 )raccuracymin_sizemax_size)r)r,rr0r1r2s r" hough_ellipser3~s!t    r$cURS:wa [S5eUc:[R"[R*S- [RS- SSS9n[ XS9$)aPerform a straight line Hough transform. Parameters ---------- image : (M, N) ndarray Input image with nonzero values representing edges. theta : ndarray of double, shape (K,), optional Angles at which to compute the transform, in radians. Defaults to a vector of 180 angles evenly spaced in the range [-pi/2, pi/2). Returns ------- hspace : ndarray of uint64, shape (P, Q) Hough transform accumulator. angles : ndarray Angles at which the transform is computed, in radians. distances : ndarray Distance values. Notes ----- The origin is the top left corner of the original image. X and Y axis are horizontal and vertical edges respectively. The distance is the minimal algebraic distance from the origin to the detected line. The angle accuracy can be improved by decreasing the step size in the `theta` array. Examples -------- Generate a test image: >>> img = np.zeros((100, 150), dtype=bool) >>> img[30, :] = 1 >>> img[:, 65] = 1 >>> img[35:45, 35:50] = 1 >>> for i in range(90): ... img[i, i] = 1 >>> rng = np.random.default_rng() >>> img += rng.random(img.shape) > 0.95 Apply the Hough transform: >>> out, angles, d = hough_line(img) r #The input image `image` must be 2D.Fendpoint)theta)ndim ValueErrorrlinspacepir)r,r9s r" hough_liner>sR^ zzQ>?? } RUUFQJ 3G u **r$c URS:wa [S5eUc:[R"[R*S- [RS- SSS9n[ UUUUUUS9$)aReturn lines from a progressive probabilistic line Hough transform. Parameters ---------- image : ndarray, shape (M, N) Input image with nonzero values representing edges. threshold : int, optional Threshold line_length : int, optional Minimum accepted length of detected lines. Increase the parameter to extract longer lines. line_gap : int, optional Maximum gap between pixels to still form a line. Increase the parameter to merge broken lines more aggressively. theta : ndarray of dtype, shape (K,), optional Angles at which to compute the transform, in radians. Defaults to a vector of 180 angles evenly spaced in the range [-pi/2, pi/2). rng : {`numpy.random.Generator`, int}, optional Pseudo-random number generator. By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`). If `rng` is an int, it is used to seed the generator. Returns ------- lines : list List of lines identified, lines in format ((x0, y0), (x1, y1)), indicating line start and end. References ---------- .. [1] C. Galamhos, J. Matas and J. Kittler, "Progressive probabilistic Hough transform for line detection", in IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 1999. r r5r6Fr7)r line_lengthline_gapr9rng)r:r;rr<r=_prob_hough_line)r,rr@rAr9rBs r"probabilistic_hough_linerDsfN zzQ>?? } RUUFQJ 3G     r$c ZSSKJn /n /n /n /n [X5HdupU"UUUUUS9unnnU RU 4[ U5-5 U RU5 U RU5 U RU5 Mf [ R "U 5n [ R "U 5n [ R "U 5n [ R "U 5n U(a[ R"X- 5nO[ R"U 5nU USSS2U USSS2U USSS2U USSS24unnnnU[ R:Xa [ U5OUnUS:XaUS:Xd[ U5S:XaUSUUSUUSUUSU4$[UUX#U5nUUUUUUUU4$)aReturn peaks in a circle Hough transform. Identifies most prominent circles separated by certain distances in given Hough spaces. Non-maximum suppression with different sizes is applied separately in the first and second dimension of the Hough space to identify peaks. For circles with different radius but close in distance, only the one with highest peak is kept. Parameters ---------- hspaces : (M, N, P) array Hough spaces returned by the `hough_circle` function. radii : (M,) array Radii corresponding to Hough spaces. min_xdistance : int, optional Minimum distance separating centers in the x dimension. min_ydistance : int, optional Minimum distance separating centers in the y dimension. threshold : float, optional Minimum intensity of peaks in each Hough space. Default is `0.5 * max(hspace)`. num_peaks : int, optional Maximum number of peaks in each Hough space. When the number of peaks exceeds `num_peaks`, only `num_peaks` coordinates based on peak intensity are considered for the corresponding radius. total_num_peaks : int, optional Maximum number of peaks. When the number of peaks exceeds `num_peaks`, return `num_peaks` coordinates based on peak intensity. normalize : bool, optional If True, normalize the accumulator by the radius to sort the prominent peaks. Returns ------- accum, cx, cy, rad : tuple of array Peak values in Hough space, x and y center coordinates and radii. Examples -------- >>> from skimage import transform, draw >>> img = np.zeros((120, 100), dtype=int) >>> radius, x_0, y_0 = (20, 99, 50) >>> y, x = draw.circle_perimeter(y_0, x_0, radius) >>> img[x, y] = 1 >>> hspaces = transform.hough_circle(img, radius) >>> accum, cx, cy, rad = hough_circle_peaks(hspaces, [radius,]) Notes ----- Circles with bigger radius have higher peaks in Hough space. If larger circles are preferred over smaller ones, `normalize` should be False. Otherwise, circles will be returned in the order of decreasing voting number. r r rNrr) rrzipextendlenrrargsortinflabel_distant_points)hspacesradiirrrrtotal_num_peaksr&rrcxcyaccumradhph_px_py_ps accum_sorted cx_sorted cy_sortedr_sortedtnp should_keeps r"hough_circle_peaksr`1sB0 A B B Eu&( ''  S# ##c("# # # S'  A "B "B HHUOE JJuy ! JJu  a2 1dd  1dd  !TrT 40L)Y /"&&8#l oC }1c,6G16LTc"IdsOYt_htPSnUU'9mCK [!++  r$c[R"[U5[S9n[R"X/SS9n[ U5nSn[ [U55Hn X:aSXY'MXY(aMURX X4[R"X#55n U HJn [X X - 5U:*n [XX- 5U:*n U (dM6U (dM?X:dMFSX['ML US- nM U)nU$)a{Keep points that are separated by certain distance in each dimension. The first point is always accepted and all subsequent points are selected so that they are distant from all their preceding ones. Parameters ---------- xs : array, shape (M,) X coordinates of points. ys : array, shape (M,) Y coordinates of points. min_xdistance : int Minimum distance separating points in the x dimension. min_ydistance : int Minimum distance separating points in the y dimension. max_points : int Max number of distant points to keep. Returns ------- should_keep : array of bool A mask array for distant points to keep. )dtyper)axisrT) rzerosrIboolstackrrangequery_ball_pointhypotabs)xsysrr max_points is_neighbor coordinateskd_treen_ptsi neighbors_inix_closey_closer_s r"rLrLs0((3r7$/K((B8!,Kk"G E 3r7^  !KN"22 FK"bfrun->bfrun->7ww26&*KO " QJE!",K r$)TF)rrwN)N)r 2r NN)numpyr scipy.spatialr_hough_transformrrrrrCrKr#r.r3r>rDr`rLr$r"r}su!HHKffF/R*Z@F6+tGK4tffFFvr/r$