voinSSKrSSKrSSKJrJrJr SSKJrJr SSK r SSK J r SSK JrJr SSKJrJrJrJrJr \ R,"S5rS rS r\"S S \55rS rSr"SS5r"SS5rS SjrSr Sr!\ "SS\55r"\ "SS\55r#\ "SS\55r$Sr%Sr&SSS\ RNSSSS4Sjr(g)!N)Protocolruntime_checkableSelf)warncatch_warnings)inv)optimizespatial)_deprecate_estimateFailedEstimationdeprecate_parameterdeprecate_func DEPRECATEDchURS:wdURSU:wa[SUS35eg)Nr rzInput data must have shape (N, z).ndimshape ValueError)datadims O/var/www/html/land-ocr/venv/lib/python3.13/site-packages/skimage/measure/fit.py_check_data_dimrs6 yyA~A#-:3%rBCC.c`URS:dURSS:a [S5eg)Nr rzInput data must be at least 2D.r)rs r_check_data_atleast_2Drs- yy1} 1 ):;;*rc.\rSrSrSr\S5rSrSrg)RansacModelProtocolz"Protocol for `ransac` model class.cgN)clsrs r from_estimate!RansacModelProtocol.from_estimate#s#&rcgr"r#selfrs r residualsRansacModelProtocol.residuals&srr#N) __name__ __module__ __qualname____firstlineno____doc__ classmethodr%r*__static_attributes__r#rrrrs,&&#rrz0.26z2.2c\rSrSrSrSrg) BaseModel-c>[S[S[3[SS9 g)Nz%`BaseModel` deprecated since version and will be removed in version r category stacklevel)r_PARAMS_DEP_START_PARAMS_DEP_STOP FutureWarningr)s r__init_subclass__BaseModel.__init_subclass__.s* 34E3FG**:); ="  rr#N)r,r-r.r/r?r2r#rrr4r4-s rr4c<\rSrSrSr\S\\-4Sj5rSr Sr g) _BaseModel7aImplement common methods for model classes. This class can be removed when we expire deprecations of ``estimate`` method, and `params` arguments to ``predict*`` methods. Note that each inheriting class will need to implement ``_params2init_values``, that breaks up the ``params`` vector into separate components comprising the arguments to the function ``__init__``, and checks the resulting input arguments for validity. returnc[SS9 U"5nSSS5 WRUSS9nUcU$[URSU35$!,(df  N==f)Nignore)actionF warn_onlyz: )r _estimater r,)r$rtfmsgs rr%_BaseModel.from_estimateCsW8 ,B-ll45l1[rP&6#,,r#7O&PP- ,s A  Ac Ub U[Lai[XRS5c*[U5Rn[ SUSUSUS35eURVs/sHn[X5PM sn$UR U5$s snf)NrzM`params` argument must be specified when applied to model initialized with ``z()``; Consider creating new z. with suitable input arguments, or by using ``z.from_estimate``.)rgetattr _init_argstyper,r_params2init_values)r)paramscls_nameas r_get_init_values_BaseModel._get_init_valuesRs >Vz1t__Q/08 :.. ! ">j!%%-J.? A/3oo>oGD$o> >''//?sBr#N) r,r-r.r/r0r1rr r%rVr2r#rrrBrB7s0  QD+;$; Q Q0rrBc4U(dU$[U[SS9 g)aIf `warn_only`, warn with `msg`, return ``None``, else return `msg` For `from_estimate` API, we want to return a ``FailedEstimation`` for these estimation failures, which we do by setting ``warn_only=False``, and passing back the `msg` from the ``_estimation`` method via this function. For the deprecated ``estimate`` API, we want to warn (``warn_only=True``), and return an incomplete transform. The ``None`` return value indicates the estimation has kind-of succeeded, for back compatibility. r8N)rRuntimeWarning)rLrIs r _warn_or_msgr[ds  ~!4 rc^[R"TR5nURVs/sH o"S:wdM UPM snTlU4SjnXlUTlT$s snf)aClass decorator to allow, deprecate no input arguments to ``__init__``. Makes a new ``__init__`` method, that a) will allow option of passing no arguments, and b) when used thus, raises a deprecation warning. Otherwise defers to an assumed-existing ``_args_init`` instance method to deal with input arguments. If there are no parameters, set desired parameters to None, to signal uninitialized object. At the end of deprecation we can drop this decorator, and rename ``_args_init`` to ``__init__``. r)c >[U5(d[U5(aUR"U0UD6 g[STRS[S[ STRS3 [ SS9 TRHn[XS5 M g)Nz Calling ``z;()`` (without arguments) has been deprecated since version r7z; see help for ``z``.r r8) len _args_initrr,r;r<r=rPsetattr)r)argskwargskr$s rinit _deprecate_no_args..inits t99F OOT ,V ,  '((9':;""2!34c ##  A DT " r)inspect signaturer_ parametersrP __signature____init__)r$ args_init_sigrcrds` r_deprecate_no_argsrltsZ%%cnn5M!.!9!9I!9A&[a!9ICN# 'CL J)Js A A c[S[[SS9"U5nURR S[5UlU$)z5Deprecate `params` argument of various model methods.rSF) start_version stop_versionmodify_docstringz{{ start_version }})rr;r<r0replace)funcs r_deprecate_model_paramsrssC '%     D <<''(=?PQDL Krc^\rSrSrSrSrSrSr\\ "\ \ SS9S55r \ U4S j5rSS jr\\4S j5r\S \4S j5r\\4Sj5r\\4Sj5r\S5rSrU=r$) LineModelNDaTotal least squares estimator for N-dimensional lines. In contrast to ordinary least squares line estimation, this estimator minimizes the orthogonal distances of points to the estimated line. Lines are defined by a point (origin) and a unit vector (direction) according to the following vector equation:: X = origin + lambda * direction Parameters ---------- origin : array-like, shape (N,) Coordinates of line origin in N dimensions. direction : array-like, shape (N,) Vector giving line direction. Raises ------ ValueError If length of `origin` and `direction` differ. Examples -------- >>> x = np.linspace(1, 2, 25) >>> y = 1.5 * x + 3 >>> lm = LineModelND.from_estimate(np.stack([x, y], axis=-1)) >>> lm.origin array([1.5 , 5.25]) >>> lm.direction # doctest: +FLOAT_CMP array([0.5547 , 0.83205]) >>> res = lm.residuals(np.stack([x, y], axis=-1)) >>> np.abs(np.round(res, 9)) 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.]) >>> np.round(lm.predict_y(x[:5]), 3) array([4.5 , 4.562, 4.625, 4.688, 4.75 ]) >>> np.round(lm.predict_x(y[:5]), 3) array([1. , 1.042, 1.083, 1.125, 1.167]) c@URX5uUlUlg)zInitialize ``LineModelND`` instance. Parameters ---------- origin : array-like, shape (N,) Coordinates of line origin in N dimensions. direction : array-like, shape (N,) Vector giving line direction. N)_check_init_valuesorigin directionr)ryrzs rr_LineModelND._args_inits'+&=&=f&P# T^rcfSX45up[U5[U5:wa [S5eX4$)Nc3N# UHn[R"U5v M g7fr")nparray).0vs r 1LineModelND._check_init_values..sF2EQRXXa[[2Es#%z7Direction vector should be same length as origin point.)r^rr{s rrxLineModelND._check_init_valuess7F62EF v;#i. (VW W  rcT[U5S:wa [S5eUR"U6$)Nr z!Input `params` should be length 2)r^rrxr)rSs rrRLineModelND._params2init_valuess+ v;! @A A&&//rzK`params` attribute deprecated; use ``origin, direction`` attributes insteaddeprecated_versionremoved_versionhintc2URUR4$)z7Return model attributes as ``origin, direction`` tuple.)ryrzr>s rrSLineModelND.paramss{{DNN**rc">[TU]U5$)aEstimate line model from data. This minimizes the sum of shortest (orthogonal) distances from the given data points to the estimated line. Parameters ---------- data : (N, dim) array N points in a space of dimensionality dim >= 2. Returns ------- model : Self or `~.FailedEstimation` An instance of the line model if the estimation succeeded. Otherwise, we return a special ``FailedEstimation`` object to signal a failed estimation. Testing the truth value of the failed estimation object will return ``False``. E.g. .. code-block:: python model = LineModelND.from_estimate(...) if not model: raise RuntimeError(f"Failed estimation: {model}") superr%r$r __class__s rr%LineModelND.from_estimates4w$T**rc^[U5 URSS9nX- nURSS:Xa5USUS- n[RR U5nUS:waXE-nO;URSS:a'[RR USS9u pgUSnOgX0lX@lg)Nraxisr rF) full_matriceszestimate under-determined) rmeanrrlinalgnormsvdryrz)r)rrIryrzr_rs rrJLineModelND._estimatest$"} ::a=A Q$q')I99>>),Dqy! ZZ]Q iimmDm>GAq!I. "rcF[U5 URU5up4[U5URS:wa([ S[U5SURSS35eX- X- U-S[ R 4U-- n[ RRUSS9$)aDetermine residuals of data to model. For each point, the shortest (orthogonal) distance to the line is returned. It is obtained by projecting the data onto the line. Parameters ---------- data : (N, dim) array N points in a space of dimension dim. Returns ------- residuals : (N,) array Residual for each data point. Other parameters ---------------- params : `~.DEPRECATED`, optional Optional custom parameter set in the form (`origin`, `direction`). .. deprecated:: {{ start_version }} rz `origin` is zD, but `data` is D.r) rrVr^rrrnewaxisrr)r)rrSryrzress rr*LineModelND.residuals$s0 t$ 11&9 v;$**Q- 's6{m+ JJqqJ !!Q$ 'rcUb U[LaUO[U5"URU56nURUSS9SS2S4nU$)aPredict y-coordinates for 2D lines using the estimated model. Alias for:: predict(x, axis=0)[:, 1] Parameters ---------- x : array x-coordinates. Returns ------- y : array Predicted y-coordinates. Other parameters ---------------- params : `~.DEPRECATED`, optional Optional custom parameter set in the form (`origin`, `direction`). .. deprecated:: {{ start_version }} Nrrrr)r)rrSrKrs r predict_yLineModelND.predict_yrrc(URU5SL$)a9Estimate line model from data. This minimizes the sum of shortest (orthogonal) distances from the given data points to the estimated line. Parameters ---------- data : (N, dim) array N points in a space of dimensionality ``dim >= 2``. Returns ------- success : bool True, if model estimation succeeds. NrJr(s restimateLineModelND.estimates"~~d#t++r)rzryT)r,r-r.r/r0r_rxrRpropertyrr;r<rSr1r%rJrsrr*rrrr rr2 __classcell__rs@rrurus(T Q! 0 ,( Z +  +++6,%/ + +D ""H",  D",  D,,rruc^\rSrSrSrSrSrSr\\ "\ \ SS9S55r \ U4S j5rSS jrS r\\4S j5r\S 5rSrU=r$) CircleModeliu5Total least squares estimator for 2D circles. The functional model of the circle is:: r**2 = (x - xc)**2 + (y - yc)**2 This estimator minimizes the squared distances from all points to the circle:: min{ sum((r - sqrt((x_i - xc)**2 + (y_i - yc)**2))**2) } A minimum number of 3 points is required to solve for the parameters. Parameters ---------- center : array-like, shape (2,) Coordinates of circle center. radius : float Circle radius. Notes ----- The estimation is carried out using a 2D version of the spherical estimation given in [1]_. References ---------- .. [1] Jekel, Charles F. Obtaining non-linear orthotropic material models for pvc-coated polyester via inverse bubble inflation. Thesis (MEng), Stellenbosch University, 2016. Appendix A, pp. 83-87. https://hdl.handle.net/10019.1/98627 Raises ------ ValueError If `center` does not have length 2. Examples -------- >>> t = np.linspace(0, 2 * np.pi, 25) >>> xy = CircleModel((2, 3), 4).predict_xy(t) >>> model = CircleModel.from_estimate(xy) >>> model.center array([2., 3.]) >>> model.radius 4.0 >>> res = model.residuals(xy) >>> np.abs(np.round(res, 9)) 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.]) The estimation can fail when — for example — all the input or output points are the same. If this happens, you will get a transform that is not "truthy" - meaning that ``bool(tform)`` is ``False``: >>> # A successfully estimated model is truthy: >>> if model: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate model with identical points. >>> bad_data = np.ones((4, 2)) >>> bad_model = CircleModel.from_estimate(bad_data) >>> if not bad_model: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_model.residuals(xy) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "residuals" for failed estimation ... c@URX5uUlUlg)zInitialize CircleModel instance. Parameters ---------- center : array-like, shape (2,) Coordinates of circle center. radius : float Circle radius. N)rxcenterradiusr)rrs rr_CircleModel._args_inits$(#:#:6#J  T[rch[R"U5n[U5S:Xd [S5eX4$)Nr %Center coordinates should be length 2rrr^rrs rrxCircleModel._check_init_valuess0&!6{aDE E~rc[R"U5n[U5S:wa [S5eUR USSUS5$)Nz!Input `params` should be length 3r rrr^rrxrs rrRCircleModel._params2init_values%sE&! v;! @A A&&vbqz6!9==rzF`params` attribute deprecated; use `center, radius` attributes insteadrcT[RURUR4$)z7Return model attributes ``center, radius`` as 1D array.)rr_rrr>s rrSCircleModel.params+s uuT[[$++-..rc">[TU]U5$)aoEstimate circle model from data using total least squares. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- model : Self or `~.FailedEstimation` An instance of the circle model if the estimation succeeded. Otherwise, we return a special ``FailedEstimation`` object to signal a failed estimation. Testing the truth value of the failed estimation object will return ``False``. E.g. .. code-block:: python model = CircleModel.from_estimate(...) if not model: raise RuntimeError(f"Failed estimation: {model}") rrs rr%CircleModel.from_estimate5s.w$T**rc[USS9 [R"UR[R5nUR USS9nUR SS9nX- nUR5nU[R"U5R:a [SUS9$X-n[R"US-[R"URSS 4US 9S S9n[R"US-S S9n[RR!XgSS 9uppU S :wa [S US9$USSn ["R$"X5n [R&"[R "U S-55n X-U-UlX-Ulg)Nr rFcopyrrzUStandard deviation of data is too small to estimate circle with meaningful precision.rHrdtype)rcondrz6Input does not contain enough significant data points.)rr promote_typesrfloat32astyperstdfinfotinyr[appendonesrsumrlstsqr minkowski_distancesqrtrr)r)rrI float_typeryscaleAfCrrankr distancesrs rrJCircleModel._estimateNs`!$%%djj"**= {{:E{2"}  288J',, ,4#   IIdQhA(:* MTU V FF47 # D9 d 19H#  1Q..v< GGBGGIqL) *nv- i rc[USS9 URup#URnUSS2S4nUSS2S4nU[R"XR- S-Xc- S--5- $)aDetermine residuals of data to model. For each point the shortest distance to the circle is returned. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- residuals : (N,) array Residual for each data point. r rNrr)rrrrr)r)rxcycrrrs rr*CircleModel.residualsxsa" !$ KK AJ AJ277AFq=AFq=8999rc[R"U5nURU5uup4nX5[R"U5--nXE[R"U5--n[R "USUS4UR S9$)aPredict x- and y-coordinates using the estimated model. Parameters ---------- t : array-like Angles in circle in radians. Angles start to count from positive x-axis to positive y-axis in a right-handed system. Returns ------- xy : (..., 2) array Predicted x- and y-coordinates. Other parameters ---------------- params : `~.DEPRECATED`, optional Optional parameters ``xc``, ``yc``, `radius`. .. deprecated:: {{ start_version }} .Nr)r asanyarrayrVcossin concatenater)r)trSrrrrrs r predict_xyCircleModel.predict_xysr, MM! ++F3 ! RVVAY  RVVAY ~~q|Qy\:HHrc(URU5SL$)zEstimate circle model from data using total least squares. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- success : bool True, if model estimation succeeds. Nrr(s rrCircleModel.estimates~~d#t++r)rrrr,r-r.r/r0r_rxrRrrr;r<rSr1r%rJr*rsrrr rr2rrs@rrrsIV K > ,( U /  /++0(T:6#-II:,,rrc^\rSrSrSrSrSrSr\\ "\ \ SS9S55r \ U4S j5rSS jrS r\\4S j5r\S 5rSrU=r$) EllipseModeliuRTotal least squares estimator for 2D ellipses. The functional model of the ellipse is:: xt = xc + a*cos(theta)*cos(t) - b*sin(theta)*sin(t) yt = yc + a*sin(theta)*cos(t) + b*cos(theta)*sin(t) d = sqrt((x - xt)**2 + (y - yt)**2) where ``(xt, yt)`` is the closest point on the ellipse to ``(x, y)``. Thus d is the shortest distance from the point to the ellipse. The estimator is based on a least squares minimization. The optimal solution is computed directly, no iterations are required. This leads to a simple, stable and robust fitting method. Parameters ---------- center : array-like, shape (2,) Coordinates of ellipse center. axis_lengths : array-like, shape (2,) Length of first axis and length of second axis. Call these ``a`` and ``b``. theta : float Angle of first axis. Raises ------ ValueError If `center` does not have length 2. Examples -------- >>> em = EllipseModel((10, 15), (8, 4), np.deg2rad(30)) >>> xy = em.predict_xy(np.linspace(0, 2 * np.pi, 25)) >>> ellipse = EllipseModel.from_estimate(xy) >>> ellipse.center array([10., 15.]) >>> ellipse.axis_lengths array([8., 4.]) >>> round(ellipse.theta, 2) 0.52 >>> np.round(abs(ellipse.residuals(xy)), 5) 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.]) The estimation can fail when — for example — all the input or output points are the same. If this happens, you will get an ellipse model for which ``bool(model)`` is ``False``: >>> # A successfully estimated model is truthy: >>> if ellipse: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate model with identical points. >>> bad_data = np.ones((4, 2)) >>> bad_ellipse = EllipseModel.from_estimate(bad_data) >>> if not bad_ellipse: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_ellipse.residuals(xy) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "residuals" for failed estimation ... cNURXU5uUlUlUlg)a"Initialize ``EllipseModel`` instance. Parameters ---------- center : array-like, shape (2,) Coordinates of ellipse center. axis_lengths : array-like, shape (2,) Length of first axis and length of second axis. Call these ``a`` and ``b``. theta : float Angle of first axis. N)rxr axis_lengthstheta)r)rrrs rr_EllipseModel._args_init s'6:5L5L %6 2 T& rcX4Vs/sHn[R"U5PM snup[U5S:Xd [S5e[U5S:Xd [S5eXU4$s snf)Nr rzAxis lengths should be length 2r)r)rrrrs rrxEllipseModel._check_init_valuessh6<5KL5K 5KL6{aDE E< A%>? ?U** Ms A#c[R"U5n[U5S:wa [S5eUR USSUSSUS5$)NrYz!Input `params` should be length 5r rrs rrR EllipseModel._params2init_values$sM&! v;! @A A&&vbqz6!A;q JJrzS`params` attribute deprecated; use `center, axis_lengths, theta` attributes insteadrcj[RURURUR4$)zDReturn model attributes ``center, axis_lengths, theta`` as 1D array.)rrrrrr>s rrSEllipseModel.params*s(uuT[[$"3"3TZZ?@@rc">[TU]U5$)ayEstimate ellipse model from data using total least squares. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- model : Self or `~.FailedEstimation` An instance of the ellipse model if the estimation succeeded. Otherwise, we return a special ``FailedEstimation`` object to signal a failed estimation. Testing the truth value of the failed estimation object will return ``False``. E.g. .. code-block:: python model = EllipseModel.from_estimate(...) if not model: raise RuntimeError(f"Failed estimation: {model}") References ---------- .. [1] Halir, R.; Flusser, J. "Numerically stable direct least squares fitting of ellipses". In Proc. 6th International Conference in Central Europe on Computer Graphics and Visualization. WSCG (Vol. 98, pp. 125-132). rrs rr%EllipseModel.from_estimate4s>w$T**rc[USS9 [U5S:a [SUS9$[R"UR [R 5nURUSS9nURSS 9nX- nUR5nU[R"U5R:a [S US9$X-nUSS2S4nUSS2S 4n[R"US-Xg-US-/5Rn[R"Xg[R"U5/5Rn URU-n URU -n U RU -n [R"/S Q/S Q/SQ/5n [!U 5X[!U 5-U R-- -n[R"R'U5unnS[R("USSS24USSS245-[R*"US SS24S5- nUSS2US:4nSUR,;d[UR/55S:wagUR/5unnn[!U 5*U R-U-nUR/5unnnUS-nUS-nUS-nUU-UU-- US-UU-- - nUU-UU-- US-UU-- - nUUS--UUS---UUS---SU-U-U-- UU-U-- n[R0"UU- S-SUS---5nUS-UU-- UUU-- -nUS-UU-- U*UU-- -n[R0"SU-U- 5n [R0"SU-U- 5n!S[R2"SU-UU- - 5-n"UU:aU"S[R4-- n"U U!:aU!U n!n U"[R4S- - n"U"[R4-n"[R6"UUU U!U"/5R8n#U#SS===U-sss&U#SS===U- sss&U#SSU#SSU#SsUlUlUlg![R"R$a gf=f)Nr rrYz3Need at least 5 data points to estimate an ellipse.rHFrrrzVStandard deviation of data is too small to estimate ellipse with meaningful precision.r)r @)r gr )r r r zSingular matrix from estimationrrzEigenvector constraints not metr g?) rr^r[rrrrrrrrrvstackT ones_likerrr LinAlgErroreigmultiplypowerrravelrarctanpi nan_to_numrealrrr)$r)rrIrryrrrD1D2S1S2S3C1Meig_valseig_vecsconda1rUbca2drgx0y0 numeratorterm denominator1 denominator2widthheightphirSs$ rrJEllipseModel._estimateUs !$ t9q=E#  %%djj"**= {{:E{2"}  288J',, ,5#   AJ AJYY1aeQT* + - - YYbll1o. / 1 1TTBY TTBY TTBYXX(8/J K 5B2SW rtt 334A  YY]]1-(2;;x1~x1~>> QTNAB  a$(m $ =C Oq04((*1a"gX_r !((*1a S S S!ea!em3Q /!ea!em3Q /1Hq1a4x'!ad(2QUQY]BQUQYN wwA!|a!Q$h./1q1u Q8 1q1u $!a%9 I 45Y56BIIsQw1q5122 q5 3; C 6>"E6E 25519 C ruu Bvs;<AAr e r f  2AJ 1QK 2J 3 T& Ayy$$ 54 5s8)Q Q-,Q-cZ^^^^^^[USS9 URummURummURn[R "U5m[R "U5mUSS2S4nUSS2S4nURSnUUUUUU4Sjn[R"U4[RS9n[R"UT- UT- 5U- n[U5HEn X9n XIn [R"XhU X4S9up[R"U"XU 55Xy'MG U$) aDetermine residuals of data to model. For each point the shortest distance to the ellipse is returned. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- residuals : (N,) array Residual for each data point. r rNrrc>[R"[R"U55n[R"[R"U55nT TT -U--TT -U-- nT TT -U--TT -U--nX- S-X&- S--$)Nr )mathrrsqueezer) rxiyictstxtytrUr$cthetasthetarrs rfun#EllipseModel.residuals..funs"**Q-(B"**Q-(Ba&j2o%F R7Ba&j2o%F R7BG>RWN2 2rr)ra)rrrrr5rrrremptyfloat64arctan2ranger leastsqr)r)rrrrNr?r*t0ir7r8rrrUr$r=r>rrs @@@@@@rr*EllipseModel.residualss " !$B  1 %% AJ AJ JJqM 3 3$HHaT4 ZZBB '% /qABB##CAbX>DA773qb>2IL rc[R"U5nURU5uup4upVn[R"U5n[R"U5n [ R"U5n [ R"U5n X5U -U--Xk-U -- n XEU -U--Xj-U --n [R "U SU S4URS9$)aPredict x- and y-coordinates using the estimated model. Parameters ---------- t : array Angles in circle in radians. Angles start to count from positive x-axis to positive y-axis in a right-handed system. Returns ------- xy : (..., 2) array Predicted x- and y-coordinates. Other parameters ---------------- params : `~.DEPRECATED`, optional Optional ellipse model parameters in the following order ``xc``, ``yc``, `a`, `b`, `theta`. .. deprecated:: {{ start_version }} rr)rrrVrrr5rr)r)rrSrrrUr$rr9r:r=r>rrs rrEllipseModel.predict_xys. MM! "&"7"7"?&1% VVAY VVAY%% Vb 1:? 2 Vb 1:? 2~~q|Qy\:HHrc(URU5SL$)aEstimate ellipse model from data using total least squares. Parameters ---------- data : (N, 2) array N points with ``(x, y)`` coordinates, respectively. Returns ------- success : bool True, if model estimation succeeds. References ---------- .. [1] Halir, R.; Flusser, J. "Numerically stable direct least squares fitting of ellipses". In Proc. 6th International Conference in Central Europe on Computer Graphics and Visualization. WSCG (Vol. 98, pp. 125-132). Nrr(s rrEllipseModel.estimate*s.~~d#t++r)rrrrrrs@rrrsDL "+K ,( b A  A++@ob>@#-!I!IF,,rrcbUS:XagUS:Xa[R$X- nSU- nSXB-- n[R"U[S[- S9n[R"U[S[- S9n[R"[R "U5[R "U5- 5$)aDetermine number trials such that at least one outlier-free subset is sampled for the given inlier/outlier ratio. Parameters ---------- n_inliers : int Number of inliers in the data. n_samples : int Total number of samples in the data. min_samples : int Minimum number of samples chosen randomly from original data. probability : float Probability (confidence) that one outlier-free sample is generated. Returns ------- trials : int Number of trials. rr)a_mina_max)rinfclip_EPSILONceillog) n_inliers n_samples min_samples probability inlier_rationomdenoms r_dynamic_max_trialsr]Ds(aA~vv (L k/C ) )E ''#XQ\ :C GGEX >E 77266#;. //rc^[TS5(a6[R"TR5(d[ STS35eT$[TS5(d[ STS35e[ S[ SS9 "U4S jS T5nU$) z=Add ``from_estimate`` method class using ``estimate`` methodr%zClass z( `from_estimate` must be a class method.rz= must have `from_estimate` class method or `estimate` method.zPassing custom classes without `from_estimate` has been deprecated since version 0.26 and will be removed in version 2.2. Add `from_estimate` class method to custom class to avoid this warning.rr8c,>\rSrSr\U4Sj5rSrg)(add_from_estimate..FromEstimatedi~cz>U"5nUR"U0UD6nU(aU$[STRS35$)N`z` estimation failed)rr r,)klassrarbinstancesuccessr$s rr%6add_from_estimate..FromEstimated.from_estimatesMwH''88G &#,,7J&KL rr#N)r,r-r.r/r1r%r2)r$sr FromEstimatedr`~s    rrg)hasattrrfismethodr% TypeErrorrr=)r$rgs` radd_from_estimaterkgssO$$ 1 122fSE)UUV V 3 # #SE$ $        rdc nSn [Rn /nUSLnUSLn[RRU 5n [ U[ [ 45(dU4n[US5nSUs=:aU::dO [SUS35eUS:a [S5eUS:a [S5eSU s=::aS::d O [S5eU b*[U 5U:wa[S [U 5S US 35eU bU OU RUUS S 9n[U5n[ U[5(d[SUS35eSnUU:aUS- nUVs/sHnUUPM nnU RUUS S 9nU(a U"U6(dMDUR"U6nU(dM\U(aU"U/UQ76(dMs[R"UR"U65nUU:nUR!U5n[R""U5nUU :d UU :Xa.UU :a(Un Un Un[%U['U UX)55nX:dX::aOUU:aM[)U5(aEUVs/sHnUUPM nnUR"U6nU(aU"U/UQ76(d [+S5 OSnSn[+S5 [-USU5U4$s snfs snf)uFit a model to data with the RANSAC (random sample consensus) algorithm. RANSAC is an iterative algorithm for the robust estimation of parameters from a subset of inliers from the complete data set. Each iteration performs the following tasks: 1. Select `min_samples` random samples from the original data and check whether the set of data is valid (see `is_data_valid`). 2. Estimate a model to the random subset (`model_cls.from_estimate(*data[random_subset]`) and check whether the estimated model is valid (see `is_model_valid`). 3. Classify all data as inliers or outliers by calculating the residuals to the estimated model (`model_cls.residuals(*data)`) - all data samples with residuals smaller than the `residual_threshold` are considered as inliers. 4. Save estimated model as best model if number of inlier samples is maximal. In case the current estimated model has the same number of inliers, it is only considered as the best model if it has less sum of residuals. These steps are performed either a maximum number of times or until one of the special stop criteria are met. The final model is estimated using all inlier samples of the previously determined best model. Parameters ---------- data : list or tuple or array of shape (N,) Data set to which the model is fitted, where N is the number of data points and the remaining dimension are depending on model requirements. If the model class requires multiple input data arrays (e.g. source and destination coordinates of ``skimage.transform.AffineTransform``), they can be optionally passed as tuple or list. Note, that in this case the functions ``estimate(*data)``, ``residuals(*data)``, ``is_model_valid(model, *random_data)`` and ``is_data_valid(*random_data)`` must all take each data array as separate arguments. model_class : type Class with the following methods: * Either: * ``from_estimate`` class method returning transform instance, as in ``tform = model_class.from_estimate(*data)``; the resulting ``tform`` should be truthy (``bool(tform) == True``) where estimation succeeded, or falsey (``bool(tform) == False``) where it failed; OR * (deprecated) ``estimate`` instance method, returning flag to indicate successful estimation, as in ``tform = model_class(); success = tform.estimate(*data)``. ``success == True`` when estimation succeeded, ``success == False`` when it failed. * ``residuals(*data)`` Your model should conform to the ``RansacModelProtocol`` — meaning implement all of the methods / attributes specified by the :class:``RansacModelProctocol``. An easy check to see whether that is the case is to use ``isinstance(MyModel, RansacModelProtocol)``. See https://docs.python.org/3/library/typing.html#typing.Protocol for more details. min_samples : int, in range (0, N) The minimum number of data points to fit a model to. residual_threshold : float, >0 Maximum distance for a data point to be classified as an inlier. is_data_valid : Callable, optional This function is called with the randomly selected data before the model is fitted to it: `is_data_valid(*random_data)`. is_model_valid : Callable, optional This function is called with the estimated model and the randomly selected data: `is_model_valid(model, *random_data)`, . max_trials : int, optional Maximum number of iterations for random sample selection. stop_sample_num : int, optional Stop iteration if at least this number of inliers are found. stop_residuals_sum : float, optional Stop iteration if sum of residuals is less than or equal to this threshold. stop_probability : float, optional, in range [0, 1] RANSAC iteration stops if at least one outlier-free set of the training data is sampled with ``probability >= stop_probability``, depending on the current best model's inlier ratio and the number of trials. This requires to generate at least N samples (trials): N >= log(1 - probability) / log(1 - e**m) where the probability (confidence) is typically set to a high value such as 0.99, e is the current fraction of inliers w.r.t. the total number of samples, and m is the min_samples value. 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. initial_inliers : array-like of bool, shape (N,), optional Initial samples selection for model estimation Returns ------- model : object Best model with largest consensus set. inliers : (N,) array Boolean mask of inliers classified as ``True``. References ---------- .. [1] "RANSAC", Wikipedia, https://en.wikipedia.org/wiki/RANSAC Examples -------- Generate ellipse data without tilt and add noise: >>> t = np.linspace(0, 2 * np.pi, 50) >>> xc, yc = 20, 30 >>> a, b = 5, 10 >>> x = xc + a * np.cos(t) >>> y = yc + b * np.sin(t) >>> data = np.column_stack([x, y]) >>> rng = np.random.default_rng(203560) # do not copy this value >>> data += rng.normal(size=data.shape) Add some faulty data: >>> data[0] = (100, 100) >>> data[1] = (110, 120) >>> data[2] = (120, 130) >>> data[3] = (140, 130) Estimate ellipse model using all available data: >>> model = EllipseModel.from_estimate(data) >>> np.round(model.center) array([71., 75.]) >>> np.round(model.axis_lengths) array([77., 13.]) >>> np.round(model.theta) 1.0 Next we estimate an ellipse model using RANSAC. Note that the results are not deterministic, because the RANSAC algorithm uses some randomness. If you need the results to be deterministic, pass a seeded number generator with the ``rng`` argument to ``ransac``. >>> ransac_model, inliers = ransac(data, EllipseModel, 20, 3, max_trials=50) >>> np.abs(np.round(ransac_model.center)) # doctest: +SKIP array([20., 30.]) >>> np.abs(np.round(ransac_model.axis_lengths)) # doctest: +SKIP array([10., 6.]) >>> np.abs(np.round(ransac_model.theta)) # doctest: +SKIP 2.0 >>> inliers # doctest: +SKIP array([False, False, False, False, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True], dtype=bool) >>> sum(inliers) > 40 True RANSAC can be used to robustly estimate a geometric transformation. In this section, we also show how to use a proportion of the total samples, rather than an absolute number. >>> from skimage.transform import SimilarityTransform >>> rng = np.random.default_rng() >>> src = 100 * rng.random((50, 2)) >>> model0 = SimilarityTransform(scale=0.5, rotation=1, ... translation=(10, 20)) >>> dst = model0(src) >>> dst[0] = (10000, 10000) >>> dst[1] = (-100, 100) >>> dst[2] = (50, 50) >>> ratio = 0.5 # use half of the samples >>> min_samples = int(ratio * len(src)) >>> model, inliers = ransac( ... (src, dst), ... SimilarityTransform, ... min_samples, ... 10, ... initial_inliers=np.ones(len(src), dtype=bool), ... ) # doctest: +SKIP >>> inliers # doctest: +SKIP array([False, False, False, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]) rNz#`min_samples` must be in range (0, ]z.`residual_threshold` must be greater than zeroz&`max_trials` must be greater than zerorz*`stop_probability` must be in range [0, 1]z4RANSAC received a vector of initial inliers (length z+) that didn't match the number of samples (z). The vector of initial inliers should have the same length as the number of samples and contain only True (this sample is an initial inlier) and False (this one isn't) values.F)rqz`model_class` z1 should be of (protocol) type RansacModelProtocolz8Estimated model is not valid. Try increasing max_trials.z"No inliers found. Model not fittedmodel)rrQrandom default_rng isinstancetuplelistr^rchoicerkrrjr%absr*dot count_nonzerominr]anyrrO)r model_classrXresidual_threshold is_data_validis_model_valid max_trialsstop_sample_numstop_residuals_sumstop_probabilityrnginitial_inliersbest_inlier_numbest_inlier_residuals_sum best_inliersvalidate_model validate_data num_samplesspl_idxs num_trialsr'samplesror*inliers residuals_sum inliers_count data_inlierss rransacrs^O "L#4/N!-M ))   $C dUDM * *wd1g,K *{ *>{m1MNNAIJJA~ABB ! &Q &EFF"s?';{'JB?#$%#}%     &  ZZ [%Z @ $K0K k#6 7 7[M*" "  J z !a )--11X;-::k;:F !8 ))73  ."A"A"A FF5??D12 00! i0 ((1  O +0!$==,O(5 %"L##[+J 2,Bi z !n <156A, 6))<8 ."F"F"F K L  12 5'5 )< 77.j7s J-J2r))rfr5typingrrrwarningsrrnumpyr numpy.linalgrscipyr r _shared.utilsr r rrrspacingrSrrrr;r<r4rBr[rlrsrurrr]rkrQrr#rrrs 44)# ::a=D < $($$  *0*0Z  "J ],*],],@ y,*y,y,x},:},},@ 0F#VFF H8r