voii SSKJr SSKrSSKrSSKJrJr SSKJr SSKrSSK r SSK J r SSK JrJrJrJrJr SSKJr S rS(S jrS(S jrS rS rSr"SS\5rSr"SS\5r"SS\5r"SS\5r"SS\5r \\"SS\ 555r!"SS\5r"S)Sjr#"SS \ 5r$\\"S!S"\$555r%"S#S$\5r&\$\%\!\"\ \\\&S%.r'S&r(S'r)g)*)copyN)ABCabstractmethod)Self)spatial) safe_as_int_deprecate_estimate_update_from_estimate_docstring_deprecate_inherited_estimateFailedEstimation)NP_COPY_IF_NEEDEDcFURnS[R"SSU--5-S- S- n[[R"U55nX#:wa[ SU35e[R "US-5n[R"XUS-45USS2SS24'U$)z8Affine matrix from linearized (d, d + 1) matrix entries.rz2Invalid number of elements for linearized matrix: N)sizenpsqrtintround ValueErroreyereshape)vnparamddimensionalitymatrixs X/var/www/html/land-ocr/venv/lib/python3.13/site-packages/skimage/transform/_geometric.py_affine_matrix_from_vectorr!s VVF RWWQV^ $ $)A-A!%N CF8 L  VVNQ& 'FZZNQ4F#GHF3B36N Mc dURup#UR5n[R"US-5nUS:XaU$[R"USS9nX- nUS:Xa.[R "[R"US-55nOmUS:XaX[R"[R "[R "US-SS955[R "U5- nO[SUS 35eUS:XaU[R-$U*US U2U4'US U2S S 24==U-ss'U$) a~Calculate transformation `matrix` to center and normalize image points. Points are an array of shape (N, D). For `scaling` of 'raw', transformation returned `matrix` will be ``np.eye(D + 1)``. For other values of `scaling`, `matrix` expresses a two-step translation and scaling procedure. Points transformed with this `matrix` usually give better conditioning for fundamental matrix estimation than the original `points` [1]_. The two steps of transformation, for `scaling` other than 'raw', are: * Center the image points, such that the new coordinate system has its origin at the centroid of the image points. * Normalize the image points, such that the mean coordinate value of the centered points is 1 (`scaling` == 'rms') or such that the mean distance from the points to the origin of the coordinate system is ``sqrt(D)`` (`scaling` == 'mrs'). If `scaling` != 'raw' and the points are all identical, the returned `matrix` will be all ``np.nan``. The 'mrs' scaling corresponds to the isotropic transformation algorithm in [1]_. 'rms' is the default, and gives very similar conditioning. Parameters ---------- points : (N, D) array The coordinates of the image points. scaling : {'rms', 'mrs', 'raw'}, optional Scaling algorithm adjusting for magnitude of `points` after applying calculated translation. See above for explanation. Returns ------- matrix : (D+1, D+1) array_like The transformation matrix to obtain the new points. References ---------- .. [1] Hartley, Richard I. "In defense of the eight-point algorithm." Pattern Analysis and Machine Intelligence, IEEE Transactions on 19.6 (1997): 580-593. rrawraxisrmsrmrszUnexpected "scaling" of ""N) shapelowerrrmeanrsumrnan)pointsscalingnrrcentroidcentereddivisors r _calc_center_normalizer5$s ^ <?"''!*L4WIQ?@@!|IF2A2q5M 2A2q5MWM Mr"c[X5n[R"[R"U55(d8U[R-[R "U[R54$U[ X 54$)zwConvenience function to calculate and apply scaling See: :func:`_calc_center_normalize` for details of the algorithm. )r5rallisfiniter. full_like_apply_homogeneous)r/r0rs r _center_and_normalize_pointsr;osY $F 4F 66"++f% & & VRVV <<< %f5 55r"c[R"U[SS9n[U5nX R-nUSS2S4n[R "US:H[R "[5RU5nUSS2SS24USS2S4- $)aTransform (N, D) `points` array with homogeneous (D+1, D+1) `matrix`. Parameters ---------- matrix : (D+1, D+1) array_like The transformation matrix to obtain the new points. Note that any object with an `__array__` method [1]_ that returns a matrix with the correct dimensions can be used as input here. This includes all subclasses of :class:`ProjectiveTransform`, for example. points : (N, D) array The coordinates of the image points. Returns ------- new_points : (N, D) array The transformed image points. References ---------- .. [1]: https://numpy.org/doc/stable/user/basics.interoperability.html#using-arbitrary-objects-in-numpy r)rndminNrr) rarrayr_append_homogeneous_dimTwherefinfofloateps)rr/points_h new_points_hdivss r r:r:zs.XXf#4A >F&v.Hhh&L 2 D 88DAIrxx22D 9D 3B3 $q$w- //r"cp[R"U[R"[U5S4545$)aAppend a column of ones to the right of `points`. This creates the representation of the points in the homogeneous coordinate space used by homogeneous matrix transforms. Parameters ---------- points : array, shape (N, D) The input coordinates, where N is the number of points and D is the dimension of the coordinate space. Returns ------- points_h : array, shape (N, D+1) The same points as homogeneous coordinates. r)rhstackoneslen)r/s r r?r?s*" 99fbggs6{A&678 99r"c[R"U5n[R"U5nURSnURSnURSS9nURSS9nX- nX- nURU-U- n [R "U4[R S9n [RRU 5S:aSXS- '[R"US-[R S9n [RRU 5upnU R5[R"U R5-[R"[5R-n[R"X:5nUS:Xa[R U -$UUS- :Xa[RRU 5[RRU5-S:aX-U SU2SU24'O`XS- nSXS- 'U [R""U 5-U-U SU2SU24'UXS- 'O%U [R""U 5-U-U SU2SU24'U(a&SUR%SS9R'5- X--nOSnUUU SU2SU24UR--- U SU2U4'U SU2SU24==U-ss'U $)aREstimate N-D similarity transformation with or without scaling. Parameters ---------- src : (M, N) array_like Source coordinates. dst : (M, N) array_like Destination coordinates. estimate_scale : bool Whether to estimate scaling factor. Returns ------- T : (N + 1, N + 1) The homogeneous similarity transformation matrix. The matrix contains NaN values only if the problem is not well-conditioned. References ---------- .. [1] "Least-squares estimation of transformation parameters between two point patterns", Shinji Umeyama, PAMI 1991, :DOI:`10.1109/34.88573` rrr%dtyperNg?)rasarrayr*r,r@rJfloat64linalgdetrsvdmaxrBrCrD count_nonzeror.diagvarr-)srcdstestimate_scalenumdimsrc_meandst_mean src_demean dst_demeanArr@USVtolranksscales r _umeyamariss0 **S/C **S/C ))A,C ))A,CxxQxHxxQxHJJ  z!C'A bjj)A yy}}Q!'  sQwbjj)AiimmAGA! %%'BFF177O #bhhuo&9&9 9C  AG $D qyvvz q 99== biimmA. . 2EAdsdDSDjM' AAAgJ NQ.AdsdDSDjMAAgJBGGAJ*$3$* jnn!n,0022ae<eq#tt}xzz'ABBAdsdCiLdsdDSDjMUM Hr"c\rSrSrSr\S5r\\S55rSr \ \S Sj55r \ S5r \ S \ \-4S j5rS rg) _GeometricTransformz2Abstract base class for geometric transformations.cg)zApply forward transformation. Parameters ---------- coords : (N, 2) array_like Source coordinates. Returns ------- coords : (N, 2) array Destination coordinates. Nselfcoordss r __call___GeometricTransform.__call__r"cg)3Return a transform object representing the inverse.Nrnrps r inverse_GeometricTransform.inversertr"cl[R"[R"U"U5U- S-SS95$)akDetermine residuals of transformed destination coordinates. For each transformed source coordinate the Euclidean distance to the respective destination coordinate is determined. Parameters ---------- src : (N, 2) array Source coordinates. dst : (N, 2) array Destination coordinates. Returns ------- residuals : (N,) array Residual for coordinate. rrr%)rrr-rprXrYs r residuals_GeometricTransform.residualss+&wwrvvtCy3141=>>r"Ncg)@Identity transform Parameters ---------- dimensionality : {None, 2}, optional This transform only allows dimensionality of 2, where None corresponds to 2. The parameter exists for compatibility with other transforms. Returns ------- tform : transform Transform such that ``np.all(tform(pts) == pts)``. Nrnclsrs r identity_GeometricTransform.identity-rtr"c[R"U5n[R"U5nURURS5X4$)z:Create identity transform and make sure points are arrays.r)rrOrr*rrXrYs r _prepare_estimation'_GeometricTransform._prepare_estimation?s:jjojjo||CIIaL)333r"returnc"[XU/UQ70UD6$)aEstimate transform. Parameters ---------- src : (N, M) array_like Source coordinates. dst : (N, M) array_like Destination coordinates. \*args : sequence Any other positional arguments. \*\*kwargs : dict Any other keyword arguments. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = TransformClass.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") _from_estimate)rrXrYargskwargss r from_estimate!_GeometricTransform.from_estimateFs:c=d=f==r"rnN)__name__ __module__ __qualname____firstlineno____doc__rrrpropertyrxr| classmethodrrrr r__static_attributes__rnr"r rkrks<    BB?*  44 >@P9P>>r"rkcURX5upQnUR"X/UQ70UD6nUcU$[URSU35$)z8Detached function for from_estimate base implementation.: )r _estimater r)rrXrYrrtfmsgs r rrfsR**34LBS ,,s 1$ 1& 1C2L"2cll^2cU3K"LLr"cZ\rSrSrSrS SS.SjjrSrSr\S Sj5r \ S 5r S r g) _HMatrixTransformimz0Transform accepting homogeneous matrix as input.NrcUc!UcSOUn[R"US-5nO[R"U5nURX5 UR UR SS- 5 Xlg)Nrrr)rrrO _check_matrix _check_dimsr*params)rprrrs r __init___HMatrixTransform.__init__ps` >#+AVVAE]FZZ'F 62 a1,- r"cUb&X!RSS- :wa[SUSU35eURSnURX34:wa [S5eg)NrrzDimensionality z does not match matrix z&Invalid shape of transformation matrix)r*r)rprrms r r_HMatrixTransform._check_matrixzsk  %a1!44 %n%55Lh  LLO <>> import numpy as np >>> import skimage as ski Define source and destination points: >>> src = np.array([1.839035, 1.924743, ... 0.543582, 0.375221, ... 0.473240, 0.142522, ... 0.964910, 0.598376, ... 0.102388, 0.140092, ... 15.994343, 9.622164, ... 0.285901, 0.430055, ... 0.091150, 0.254594]).reshape(-1, 2) >>> dst = np.array([1.002114, 1.129644, ... 1.521742, 1.846002, ... 1.084332, 0.275134, ... 0.293328, 0.588992, ... 0.839509, 0.087290, ... 1.779735, 1.116857, ... 0.878616, 0.602447, ... 0.642616, 1.028681]).reshape(-1, 2) Estimate the transformation matrix: >>> tform = ski.transform.FundamentalMatrixTransform.from_estimate( ... src, dst) >>> tform.params array([[-0.21785884, 0.41928191, -0.03430748], [-0.07179414, 0.04516432, 0.02160726], [ 0.24806211, -0.42947814, 0.02210191]]) Compute the Sampson distance: >>> tform.residuals(src, dst) array([0.0053886 , 0.00526101, 0.08689701, 0.01850534, 0.09418259, 0.00185967, 0.06160489, 0.02655136]) Apply inverse transformation: >>> tform.inverse(dst) array([[-0.0513591 , 0.04170974, 0.01213043], [-0.21599496, 0.29193419, 0.00978184], [-0.0079222 , 0.03758889, -0.00915389], [ 0.14187184, -0.27988959, 0.02476507], [ 0.05890075, -0.07354481, -0.00481342], [-0.21985267, 0.36717464, -0.01482408], [ 0.01339569, -0.03388123, 0.00497605], [ 0.03420927, -0.1135812 , 0.02228236]]) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((8, 2)) >>> bad_tform = ski.transform.FundamentalMatrixTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... r'cF[U5URR-$)zApply forward transformation. Parameters ---------- coords : (N, 2) array_like Source coordinates. Returns ------- coords : (N, 3) array Epipolar lines in the destination image. )r?rr@ros r rr#FundamentalMatrixTransform.__call__s'v.>>r"cH[U5"URRS9$)zReturn a transform object representing the inverse. See Hartley & Zisserman, Ch. 8: Epipolar Geometry and the Fundamental Matrix, for an explanation of why F.T gives the inverse. r)rrr@rws r rx"FundamentalMatrixTransform.inverse-sDz//r"c[R"U5n[R"U5nURUR:wa [S5eURSS:a [S5e[ XR 5n[ X R 5n[R "[R"X4-55(aS[R"S[R5Ul S[R"S[R5/-$[[X155n[[XB55nURVVs/sHouRHoU-PM M n nn[R"U SS9n [RR!U 5u pU S S S 24R#SS5n XU4$s snnf) aTSetup and solve the homogeneous epipolar constraint matrix:: dst' * F * src = 0. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- F_normalized : (3, 3) array The normalized solution to the homogeneous system. If the system is not well-conditioned, this matrix contains NaNs. src_matrix : (3, 3) array The transformation matrix to obtain the normalized source coordinates. dst_matrix : (3, 3) array The transformation matrix to obtain the normalized destination coordinates. z%src and dst shapes must be identical.rz,src.shape[0] must be equal or larger than 8.rrrr%rN)rrOr*rr5r0anyisnanfullr.rr?r:r@stackrQrSr)rprXrY src_matrix dst_matrixsrc_hdst_hd_vs_vcolsra_rd F_normalizeds r _setup_constraint_matrix3FundamentalMatrixTransform._setup_constraint_matrix7s[2jjojjo 99 !DE E 99Q +C> 66"((:23 4 4''&"&&1DK/00 0'(::(KL'(::(KL (-wwBw''3s'wB HHT "))--"1Qx''1- 33Cs!G c">[TU]X5$)a Estimate fundamental matrix using 8-point algorithm. The 8-point algorithm requires at least 8 corresponding point pairs. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = FundamentalMatrixTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") Raises ------ ValueError If `src` has fewer than 8 rows. superrrrXrY __class__s r r(FundamentalMatrixTransform.from_estimatems@w$S..r"cJURX5up4n[R"[R"X4-U-55(ag[RR U5upgnSUS'U[R "U5-U-n URU -U-Ulg)NScaling failed for input pointsrr rrrrrQrSrVr@r) rprXrYrrrrbrcrdFs r r$FundamentalMatrixTransform._estimates/3/L/LS/V, * 66"((<4zAB C C4))-- -a!  NQ  llQ&3 r"c[U5n[U5nURUR-nURRUR-n[R"XER-SS9n[R "U5[R "USS-USS--USS--USS--5- $)aCompute the Sampson distance. The Sampson distance is the first approximation to the geometric error. Parameters ---------- src : (N, 2) array Source coordinates. dst : (N, 2) array Destination coordinates. Returns ------- residuals : (N,) array Sampson distance. rr%rr)r?rr@rr-absr)rprXrYsrc_homogeneousdst_homogeneousF_srcFt_dst dst_F_srcs r r|$FundamentalMatrixTransform.residualss$2#61#6 o///!2!22FF?WW41= vvi 277 !HME!HM )F1IN :VAY!^ K$   r"c(URX5SL$)aEstimate fundamental matrix using 8-point algorithm. The 8-point algorithm requires at least 8 corresponding point pairs for a well-conditioned solution, otherwise the over-determined solution is estimated. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- success : bool True, if model estimation succeeds. Nrr{s r estimate#FundamentalMatrixTransform.estimate*~~c'4//r"r)rrrrrr0rrrrxrrrrr|r rr __classcell__rs@r rrsctlG? 0044l//B  <00r"rct^\rSrSrSrSrSrSSSSS.U4SjjrSr\ U4Sj5r S r \ S 5r S rU=r$) EssentialMatrixTransformia& Essential matrix transformation. The essential matrix relates corresponding points between a pair of calibrated images. The matrix transforms normalized, homogeneous image points in one image to epipolar lines in the other image. The essential matrix is only defined for a pair of moving images capturing a non-planar scene. In the case of pure rotation or planar scenes, the homography describes the geometric relation between two images (`ProjectiveTransform`). If the intrinsic calibration of the images is unknown, the fundamental matrix describes the projective relation between the two images (`FundamentalMatrixTransform`). References ---------- .. [1] Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003. Parameters ---------- rotation : (3, 3) array_like, optional Rotation matrix of the relative camera motion. translation : (3, 1) array_like, optional Translation vector of the relative camera motion. The vector must have unit length. matrix : (3, 3) array_like, optional Essential matrix. dimensionality : int, optional Fallback number of dimensions when `matrix` not specified, in which case, must equal 2 (the default). Attributes ---------- params : (3, 3) array Essential matrix. Examples -------- >>> import numpy as np >>> import skimage as ski >>> >>> tform = ski.transform.EssentialMatrixTransform( ... rotation=np.eye(3), translation=np.array([0, 0, 1]) ... ) >>> tform.params array([[ 0., -1., 0.], [ 1., 0., 0.], [ 0., 0., 0.]]) >>> src = np.array([[ 1.839035, 1.924743], ... [ 0.543582, 0.375221], ... [ 0.47324 , 0.142522], ... [ 0.96491 , 0.598376], ... [ 0.102388, 0.140092], ... [15.994343, 9.622164], ... [ 0.285901, 0.430055], ... [ 0.09115 , 0.254594]]) >>> dst = np.array([[1.002114, 1.129644], ... [1.521742, 1.846002], ... [1.084332, 0.275134], ... [0.293328, 0.588992], ... [0.839509, 0.08729 ], ... [1.779735, 1.116857], ... [0.878616, 0.602447], ... [0.642616, 1.028681]]) >>> tform = ski.transform.EssentialMatrixTransform.from_estimate(src, dst) >>> tform.residuals(src, dst) array([0.42455187, 0.01460448, 0.13847034, 0.12140951, 0.27759346, 0.32453118, 0.00210776, 0.26512283]) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((8, 2)) >>> bad_tform = ski.transform.EssentialMatrixTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... gư>N)rotation translationrrc>[SX455nUS:Xa [S5eUS:XaUb [S5eURX5n[TU]X4S9 g)Nc3(# UHoSLv M g7frrn.0ps r 4EssentialMatrixTransform.__init__..=C+BaT +Brz=Both rotation and translation required when one is specified.rz@Do not specify rotation or translation when matrix is specified.rr)r-r _rt2matrixrr)rprrrr n_rt_noners r r!EssentialMatrixTransform.__init__:spCH+BCC >O !^! +__X;F Fr"c8[R"U5n[R"U5nURS:wa [S5e[ [R R U5S- 5UR:a [S5eURS:wa [S5e[ [R RU5S- 5UR:a [S5eUup4n[R"SU*U/USU*/U*US//[S 9nXa-$) Nrz Invalid shape of rotation matrixrz*Rotation matrix must have unit determinantrz#Invalid shape of translation vectorz(Translation vector must have unit lengthrrM) rrOr*rrrQrR _rot_det_tolrnorm_trans_len_tolr>rC)rprrt0t1t2t_arrs r r#EssentialMatrixTransform._rt2matrixKs::h'jj- >>V #?@ @ ryy}}X&* +d.?.? ?IJ J   q BC C ryy~~k*Q. /$2E2E EGH H 1rc2,Q sBlC5Qr"c">[TU]X5$)a]Estimate essential matrix using 8-point algorithm. The 8-point algorithm requires at least 8 corresponding point pairs for a well-conditioned solution, otherwise the over-determined solution is estimated. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = EssentialMatrixTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") Raises ------ ValueError If `src` has fewer than 8 rows. rrs r r&EssentialMatrixTransform.from_estimate[sFw$S..r"c|URX5up4n[R"[R"X4-U-55(ag[RR U5upgnUSUS-S- US'USUS'SUS'U[R "U5-U-n URU -U-Ulg)Nrrrg@rr) rprXrY E_normalizedrrrbrcrdEs r r"EssentialMatrixTransform._estimates/3/L/LS/V, * 66"((<4zAB C C4))-- -a!qt s"!t!!  NQ  llQ&3 r"c(URX5SL$)aEstimate essential matrix using 8-point algorithm. The 8-point algorithm requires at least 8 corresponding point pairs for a well-conditioned solution, otherwise the over-determined solution is estimated. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- success : bool True, if model estimation succeeds. Nrr{s r r!EssentialMatrixTransform.estimaterr"r)rrrrrrrrrrrrr rrrrs@r rrsb]@LNDdGG" "/"/H"00r"rc^\rSrSrSrSr\S5rSr\S5r SSjr Sr \S 5r \ SU4S jj5rSS jrS rS rSrSr\S5r\ SU4Sjj5r\SSj5rSrU=r$)ProjectiveTransformia Projective transformation. Apply a projective transformation (homography) on coordinates. For each homogeneous coordinate :math:`\mathbf{x} = [x, y, 1]^T`, its target position is calculated by multiplying with the given matrix, :math:`H`, to give :math:`H \mathbf{x}`:: [[a0 a1 a2] [b0 b1 b2] [c0 c1 1 ]]. E.g., to rotate by theta degrees clockwise, the matrix should be:: [[cos(theta) -sin(theta) 0] [sin(theta) cos(theta) 0] [0 0 1]] or, to translate x by 10 and y by 20:: [[1 0 10] [0 1 20] [0 0 1 ]]. Parameters ---------- matrix : (D+1, D+1) array_like, optional Homogeneous transformation matrix. dimensionality : int, optional Fallback number of dimensions when `matrix` not specified. Attributes ---------- params : (D+1, D+1) array Homogeneous transformation matrix. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transform with an homogeneous transformation matrix: >>> tform = ski.transform.ProjectiveTransform(np.diag([2., 3., 1.])) >>> tform.params array([[2., 0., 0.], [0., 3., 0.], [0., 0., 1.]]) You can estimate a transformation to map between source and destination points: >>> src = np.array([[150, 150], ... [250, 100], ... [150, 200]]) >>> dst = np.array([[200, 200], ... [300, 150], ... [150, 400]]) >>> tform = ski.transform.ProjectiveTransform.from_estimate(src, dst) >>> np.allclose(tform.params, [[ -16.56, 5.82, 895.81], ... [ -10.31, -8.29, 2075.43], ... [ -0.05, 0.02, 1. ]], atol=0.01) True Apply the transformation to some image data. >>> img = ski.data.astronaut() >>> warped = ski.transform.warp(img, inverse_map=tform.inverse) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((3, 2)) >>> bad_tform = ski.transform.ProjectiveTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... r'cF[URRS- 5$z?Indices into flat ``self.params`` with coefficients to estimater)rangerrrws r _coeff_indsProjectiveTransform._coeff_inds sT[[%%)**r"c@US:ag[S[U5S35e)Nrrz# should result in transform of >=2Drrs r rProjectiveTransform._check_dimss* 6 !d $G H  r"cT[RRUR5$r)rrQinvrrws r _inv_matrixProjectiveTransform._inv_matrixsyy}}T[[))r"cVUc UR$URRU5$r)rastype)rprNrs r __array__ProjectiveTransform.__array__s$#mt{{J1C1CE1JJr"c.[URU5$)zApply forward transformation. Parameters ---------- coords : (N, D) array_like Source coordinates. Returns ------- coords_out : (N, D) array Destination coordinates. )r:rros r rrProjectiveTransform.__call__s"$++v66r"c4[U5"URS9$)rvr)rrrws r rxProjectiveTransform.inverse.sDz!1!122r"c$>[TU]XU5$)a Estimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. The transformation is defined as:: X = (a0*x + a1*y + a2) / (c0*x + c1*y + 1) Y = (b0*x + b1*y + b2) / (c0*x + c1*y + 1) These equations can be transformed to the following form:: 0 = a0*x + a1*y + a2 - c0*x*X - c1*y*X - X 0 = b0*x + b1*y + b2 - c0*x*Y - c1*y*Y - Y which exist for each set of corresponding points, so we have a set of N * 2 equations. The coefficients appear linearly so we can write A x = 0, where:: A = [[x y 1 0 0 0 -x*X -y*X -X] [0 0 0 x y 1 -x*Y -y*Y -Y] ... ... ] x.T = [a0 a1 a2 b0 b1 b2 c0 c1 c3] In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3. Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalized, square-rooted, then built into a diagonal matrix, by which A is multiplied. In case of the affine transformation the coefficients c0 and c1 are 0. Thus the system of equations is:: A = [[x y 1 0 0 0 -X] [0 0 0 x y 1 -Y] ... ... ] x.T = [a0 a1 a2 b0 b1 b2 c3] Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. weights : (N,) array_like, optional Relative weight values for each pair of points. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = ProjectiveTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") r)rrXrYweightsrs r r!ProjectiveTransform.from_estimate3sVw$Sw77r"c [R"U5n[R"U5nURupE[R"US-US-4[R5n[ U5upq[ U5up[R "[R"Xx-55(dX`lg[R"XE-US-S-45n [U5Hn XX-U S-U-2XS--XS--U-24'SXU-U S-U-2XS--U-4'XX-U S-U-2U*S- S24'SXU-U S-U-2S4'XU-U S-U-2U*S- S24==USS2XS-24*-ss'M U SS2[UR5S/-4n Uc#[RRU 5u pO[R"U5n[R"[R "[R""U[R$"U5- 5U55n [RRX-5u p[R"US-US-45n[R&"U SS5(aX`lgU SSS24*U S- UR([UR5S/-'SXU4'[RR+U5U-U-nXS-nXlg)NrzScaling generated NaN valuesrrrrrz)Right singular vector has 0 final element)rrOr*rr.r;r7r8rzerosrlistrrQrSrVtilerrTiscloseflatr)rprXrYr"r1r fail_matrixrrraddimrrdWHs r rProjectiveTransform._estimatesjjojjoyyggq1ua!enbff5 6s; 6s; vvbkk*"9:;;%K1 HHaea!e\* +!HDPSdh$(a'Q$a%.1:L)LL M?@AQh$(a'Q!);; <8;dh$(a'!a"4 5/1AQh$(a'+ , Qh$(a'!a1 2s1dQh>O;O7P6P P 2  ad&&'2$.. / ?iimmA&GAq!jj)G"&&/(A BAFGAiimmAE*GAq HHa!eQU^ $ ::ai # #%K>122ss7 ai0GtD$$%,-Q$ IIMM* % )J 6 vY r"c[U[5(aJ[U5[U5:Xa URnO[nU"URUR-5$[ S5e)z)Combine this transformation with another.z2Cannot combine transformations of differing types.) isinstancer rrr TypeError)rpothertforms r __add__ProjectiveTransform.__add__sT e0 1 1DzT%[(+ 34 4ST Tr"c[US5(dg[R"URSS9nS[R "US5-$)z.common 'paramstr' used by __str__ and __repr__rzz, ) separatorzmatrix= z )hasattrr array2stringrtextwrapindent)rpnpstrings r __nice__ProjectiveTransform.__nice__s<tX&&*??4;;$?X__Xv>>>r"c S[U5RSUR5S[[ U55S3$)z5Add standard repr formatting around a __nice__ string<(z) at >)rrr>hexidrws r __repr__ProjectiveTransform.__repr__s74:&&'q(9s2d8}oQOOr"cVS[U5RSUR5S3$)z4Add standard str formatting around a __nice__ stringrArBz)>)rrr>rws r __str__ProjectiveTransform.__str__s)4:&&'q(9<[TU]US9$)zIdentity transform Parameters ---------- dimensionality : {None, int}, optional Dimensionality of identity transform. Returns ------- tform : transform Transform such that ``np.all(tform(pts) == pts)``. r)rr)rrrs r rProjectiveTransform.identitysw~>>r"c*URXU5SL$)a}Estimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. The transformation is defined as:: X = (a0*x + a1*y + a2) / (c0*x + c1*y + 1) Y = (b0*x + b1*y + b2) / (c0*x + c1*y + 1) These equations can be transformed to the following form:: 0 = a0*x + a1*y + a2 - c0*x*X - c1*y*X - X 0 = b0*x + b1*y + b2 - c0*x*Y - c1*y*Y - Y which exist for each set of corresponding points, so we have a set of N * 2 equations. The coefficients appear linearly so we can write A x = 0, where:: A = [[x y 1 0 0 0 -x*X -y*X -X] [0 0 0 x y 1 -x*Y -y*Y -Y] ... ... ] x.T = [a0 a1 a2 b0 b1 b2 c0 c1 c3] In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3. Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalized, square-rooted, then built into a diagonal matrix, by which A is multiplied. In case of the affine transformation the coefficients c0 and c1 are 0. Thus the system of equations is:: A = [[x y 1 0 0 0 -X] [0 0 0 x y 1 -Y] ... ... ] x.T = [a0 a1 a2 b0 b1 b2 c3] Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. weights : (N,) array_like, optional Relative weight values for each pair of points. Returns ------- success : bool True, if model estimation succeeds. Nr)rprXrYr"s r rProjectiveTransform.estimatesD~~c0D88r"rNNr)rrrrrr0rrrrrrrrxrrrr5r>rFrIrrr rrrrs@r r r s]~G ++ **K7 33J8J8X7r U?P=(( ? ?A9A9r"r c^\rSrSrSrS SSSSSS.U4Sjjjr\S5rSr\S5r \S 5r \S 5r \S 5r S r U=r$)AffineTransformi/aAffine transformation. Has the following form:: X = a0 * x + a1 * y + a2 = sx * x * [cos(rotation) + tan(shear_y) * sin(rotation)] - sy * y * [tan(shear_x) * cos(rotation) + sin(rotation)] + translation_x Y = b0 * x + b1 * y + b2 = sx * x * [sin(rotation) - tan(shear_y) * cos(rotation)] - sy * y * [tan(shear_x) * sin(rotation) - cos(rotation)] + translation_y where ``sx`` and ``sy`` are scale factors in the x and y directions. This is equivalent to applying the operations in the following order: 1. Scale 2. Shear 3. Rotate 4. Translate The homogeneous transformation matrix is:: [[a0 a1 a2] [b0 b1 b2] [0 0 1]] In 2D, the transformation parameters can be given as the homogeneous transformation matrix, above, or as the implicit parameters, scale, rotation, shear, and translation in x (a2) and y (b2). For 3D and higher, only the matrix form is allowed. In narrower transforms, such as the Euclidean (only rotation and translation) or Similarity (rotation, translation, and a global scale factor) transforms, it is possible to specify 3D transforms using implicit parameters also. Parameters ---------- matrix : (D+1, D+1) array_like, optional Homogeneous transformation matrix. If this matrix is provided, it is an error to provide any of scale, rotation, shear, or translation. scale : {s as float or (sx, sy) as array, list or tuple}, optional Scale factor(s). If a single value, it will be assigned to both sx and sy. Only available for 2D. .. versionadded:: 0.17 Added support for supplying a single scalar value. shear : float or 2-tuple of float, optional The x and y shear angles, clockwise, by which these axes are rotated around the origin [2]. If a single value is given, take that to be the x shear angle, with the y angle remaining 0. Only available in 2D. rotation : float, optional Rotation angle, clockwise, as radians. Only available for 2D. translation : (tx, ty) as array, list or tuple, optional Translation parameters. Only available for 2D. dimensionality : int, optional Fallback number of dimensions for transform when none of `matrix`, `scale`, `rotation`, `shear` or `translation` are specified. If any of `scale`, `rotation`, `shear` or `translation` are specified, must equal 2 (the default). Attributes ---------- params : (D+1, D+1) array Homogeneous transformation matrix. Raises ------ ValueError If both ``matrix`` and any of the other parameters are provided. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transform with an homogeneous transformation matrix: >>> tform = ski.transform.AffineTransform(np.diag([2., 3., 1.])) >>> tform.params array([[2., 0., 0.], [0., 3., 0.], [0., 0., 1.]]) Define a transform with parameters: >>> tform = ski.transform.AffineTransform(scale=4, rotation=0.2) >>> np.round(tform.params, 2) array([[ 3.92, -0.79, 0. ], [ 0.79, 3.92, 0. ], [ 0. , 0. , 1. ]]) You can estimate a transformation to map between source and destination points: >>> src = np.array([[150, 150], ... [250, 100], ... [150, 200]]) >>> dst = np.array([[200, 200], ... [300, 150], ... [150, 400]]) >>> tform = ski.transform.AffineTransform.from_estimate(src, dst) >>> np.allclose(tform.params, [[ 0.5, -1. , 275. ], ... [ 1.5, 4. , -625. ], ... [ 0. , 0. , 1. ]]) True Apply the transformation to some image data. >>> img = ski.data.astronaut() >>> warped = ski.transform.warp(img, inverse_map=tform.inverse) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((3, 2)) >>> bad_tform = ski.transform.AffineTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... References ---------- .. [1] Wikipedia, "Affine transformation", https://en.wikipedia.org/wiki/Affine_transformation#Image_transformation .. [2] Wikipedia, "Shear mapping", https://en.wikipedia.org/wiki/Shear_mapping N)rhshearrrrc>[SX$X5455nUS:waRUb [S5eUbUS:a [S5eURX$X55nURSS:wa [S5e[TU]XS 9 g) Nc3(# UHoSLv M g7frrnrs r r+AffineTransform.__init__..sS-Rt)-Rrr@Do not specify any implicit parameters when matrix is specified.rz0Implicit parameters only valid for 2D transformsrrz+Implicit parameters must give 2D transformsr)r-r _srst2matrixr*rr) rprrhrTrrr n_srst_noners r rAffineTransform.__init__sSeu-RSS ! ! +)nq.@ !STT&&uKF||A!# !NOO Fr"cL[URURS--5$r)rrrws r rAffineTransform._coeff_indss%T((D,?,?!,CDEEr"cUcSOUn[R"U5(aX4OUupVUcSOUn[R"U5(d [S5eUcSOUn[R"U5(aUS4OUupxUcSOUn[R"U5(a [S5eUupU[R"U5[R "U5[R "U5---n U*[R "U5[R"U5-[R "U5--n U[R "U5[R "U5[R"U5-- -n U*[R "U5[R "U5-[R"U5- -n[R"XU /XU //SQ/5$)Nrrrz%rotation must be scalar (2D rotation)rrztranslation must be length 2rrr)risscalarrmathcostansinr>)rprhrrTrsxsyshear_xshear_ya2b2a0a1b0b1s r rYAffineTransform._srst2matrixs-U#%;;u#5#5%5 (1h{{8$$DE E])+U););E1: + 3f ;;{ # #;< < 488H%(9DHHX??r"cURS:wa [S5e[R"URS*URS5nXR - $)Nrz9The shear property is only implemented for 2D transforms.)rrr_)rrrcrwrr)rpbetas r rTAffineTransform.shear sT   ! #%K zz4;;t,,dkk$.?@mm##r"cPURSUR2UR4$Nrrrrws r rAffineTransform.translation'{{1t222D4G4GGHHr"rnr)rrrrrrrrrYrhrrTrrrrs@r rSrS/sSnGGG2FFA(22@@$$IIr"rSc|^\rSrSrSrSr\U4Sj5rSrSr \ S5r \S Sj5r \ S 5rS rU=r$) PiecewiseAffineTransformiamPiecewise affine transformation. Control points are used to define the mapping. The transform is based on a Delaunay triangulation of the points to form a mesh. Each triangle is used to find a local affine transform. Attributes ---------- affines : list of AffineTransform objects Affine transformations for each triangle in the mesh. inverse_affines : list of AffineTransform objects Inverse affine transformations for each triangle in the mesh. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transformation by estimation: >>> src = [[-12.3705, -10.5075], ... [-10.7865, 15.4305], ... [8.6985, 10.8675], ... [11.4975, -9.5715], ... [7.8435, 7.4835], ... [-5.3325, 6.5025], ... [6.7905, -6.3765], ... [-6.1695, -0.8235]] >>> dst = [[0, 0], ... [0, 5800], ... [4900, 5800], ... [4900, 0], ... [4479, 4580], ... [1176, 3660], ... [3754, 790], ... [1024, 1931]] >>> tform = ski.transform.PiecewiseAffineTransform.from_estimate(src, dst) Calling the transform applies the transformation to the points: >>> np.allclose(tform(src), dst) True You can apply the inverse transform: >>> np.allclose(tform.inverse(dst), src) True The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = [[1, 1]] * 6 + src[6:] >>> bad_tform = ski.transform.PiecewiseAffineTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... c<SUlSUlSUlSUlgr) _tesselation_inverse_tesselationaffinesinverse_affinesrws r r!PiecewiseAffineTransform.__init__bs! $(! #r"c">[TU]X5$)aEstimate the transformation from a set of corresponding points. Number of source and destination coordinates must match. Parameters ---------- src : (N, D) array_like Source coordinates. dst : (N, D) array_like Destination coordinates. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = PiecewiseAffineTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") rrs r r&PiecewiseAffineTransform.from_estimatehs8w$S..r"c[R"U5n[R"U5nURup4[R"U5Ul[R "US-US-4[R5n/Ul/n[UR R5Hyupx[RXSS24X(SS245n U (d0URSUSU 35 [UR55n URRU 5 M{ [R"U5Ul/Ul[URR5Hyupx[RX(SS24XSS245n U (d0URSUSU 35 [UR55n UR RU 5 M{ U(aSR#U5$S$)NrzFailure at forward simplex rzFailure at inverse simplex z; )rrOr*rDelaunayrrr.r enumerate simplicesrSrappendrrrjoin) rprXrYNDr+messagesitriaffines r r"PiecewiseAffineTransform._estimatesjjojjoyy$,,S1ggq1ua!enbff5   1 1 ; ;CA  = r"c[U5"5n[UR5Ul[UR5Ul[UR5Ul[UR 5UlU$)rv)rrrrrr)rpr4s r rx PiecewiseAffineTransform.inverses]T !$";";<%)$*;*;%<"T112 $T\\ 2 r"cU"5$)a>Identity transform Parameters ---------- dimensionality : optional This transform does not use the `dimensionality` parameter, so the value is ignored. The parameter exists for compatibility with other transforms. Returns ------- tform : transform Transform such that ``np.all(tform(pts) == pts)``. rnrs r r!PiecewiseAffineTransform.identitys u r"c(URX5SL$)aXEstimate the transformation from a set of corresponding points. Number of source and destination coordinates must match. Parameters ---------- src : (N, D) array_like Source coordinates. dst : (N, D) array_like Destination coordinates. Returns ------- success : bool True, if all pieces of the model are successfully estimated. Nrr{s r r!PiecewiseAffineTransform.estimates&~~c'4//r")rrrrr)rrrrrrrrrrrrrxrr rrrrs@r rrskHT$ //:!9F!F"00r"rcn[RRRSXS9R 5$)aProduce an Euler rotation matrix from the given intrinsic rotation angles for the axes x, y and z. Parameters ---------- angles : array of float, shape (3,) The transformation angles in radians. degrees : bool, optional If True, then the given angles are assumed to be in degrees. Default is False. Returns ------- R : array of float, shape (3, 3) The Euler rotation matrix. XYZanglesdegrees)r transformRotation from_euler as_matrixrs r _euler_rotation_matrixrs4"    % % 0 0 f 1 ikr"c^\rSrSrSrSrSSSSS.U4SjjjrSrSr\ S \ \ -4S j5r S r \S 5r\S 5r\S5rSrU=r$)EuclideanTransformiaEuclidean transformation, also known as a rigid transform. Has the following form:: X = a0 * x - b0 * y + a1 = = x * cos(rotation) - y * sin(rotation) + a1 Y = b0 * x + a0 * y + b1 = = x * sin(rotation) + y * cos(rotation) + b1 where the homogeneous transformation matrix is:: [[a0 -b0 a1] [b0 a0 b1] [0 0 1 ]] The Euclidean transformation is a rigid transformation with rotation and translation parameters. The similarity transformation extends the Euclidean transformation with a single scaling factor. In 2D and 3D, the transformation parameters may be provided either via `matrix`, the homogeneous transformation matrix, above, or via the implicit parameters `rotation` and/or `translation` (where `a1` is the translation along `x`, `b1` along `y`, etc.). Beyond 3D, if the transformation is only a translation, you may use the implicit parameter `translation`; otherwise, you must use `matrix`. The implicit parameters are applied in the following order: 1. Rotation; 2. Translation. Parameters ---------- matrix : (D+1, D+1) array_like, optional Homogeneous transformation matrix. rotation : float or sequence of float, optional Rotation angle, clockwise, in radians. If given as a vector, it is interpreted as Euler rotation angles [1]_. Only 2D (single rotation) and 3D (Euler rotations) values are supported. For higher dimensions, you must provide or estimate the transformation matrix instead, and pass that as `matrix` above. translation : (x, y[, z, ...]) sequence of float, length D, optional Translation parameters for each axis. dimensionality : int, optional Fallback number of dimensions for transform when no other parameter is specified. Otherwise ignored, and we infer dimensionality from the input parameters. Attributes ---------- params : (D+1, D+1) array Homogeneous transformation matrix. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transform with an homogeneous transformation matrix: >>> tform = ski.transform.EuclideanTransform(np.diag([2., 3., 1.])) >>> tform.params array([[2., 0., 0.], [0., 3., 0.], [0., 0., 1.]]) Define a transform with parameters: >>> tform = ski.transform.EuclideanTransform( ... rotation=0.2, translation=[1, 2]) >>> np.round(tform.params, 2) array([[ 0.98, -0.2 , 1. ], [ 0.2 , 0.98, 2. ], [ 0. , 0. , 1. ]]) You can estimate a transformation to map between source and destination points: >>> src = np.array([[150, 150], ... [250, 100], ... [150, 200]]) >>> dst = np.array([[200, 200], ... [300, 150], ... [150, 400]]) >>> tform = ski.transform.EuclideanTransform.from_estimate(src, dst) >>> np.allclose(tform.params, [[ 0.99, 0.12, 16.77], ... [-0.12, 0.99, 122.91], ... [ 0. , 0. , 1. ]], atol=0.01) True Apply the transformation to some image data. >>> img = ski.data.astronaut() >>> warped = ski.transform.warp(img, inverse_map=tform.inverse) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((3, 2)) >>> bad_tform = ski.transform.EuclideanTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... References ---------- .. [1] https://en.wikipedia.org/wiki/Rotation_matrix#In_three_dimensions FN)rrrc>[SX#455nUS:waAUb [S5eURX#5upgUb [U5eURX#U5n[TU]XS9 g)Nc3(# UHoSLv M g7frrnrs r r.EuclideanTransform.__init__..rrrrXr)r-r _rt2ndims_msgrrr) rprrrrrn_dimschk_msgrs r rEuclideanTransform.__init__s|CH+BCC >! +#00GOF" ))__XFCF Fr"cUb@[R"U5(aSO [U5nUS;aSOSnUS:XaSU4$UU4$Ub,[R"U5(aSS4$[U5S4$g)Nr)rrz2``rotations`` must be scalar (3D) or length 3 (3D)rrQ)rrbrK)rprrrrs r r EuclideanTransform._rt2ndims_msgs  [[**H AF?E  Q1s* *As* *  "[11AN Ns;7GN Nr"cRUcSU-nUcUS:XaSO[R"S5n[R"US-5nUS:Xa<[R"U5[R "U5peXV*/Xe//USS2SS24'OUS:Xa[ U5USS2SS24'X$SU2U4'U$)N)rrrrr)rr&rrcrdrfr)rprrrrcos_rsin_rs r rEuclideanTransform._rt2matrixs  -K  "aKqRXXa[H # Q;88H-txx/A5$fo~>F2A2rr6N q[3H=F2A2rr6N#.qx  r"rc[XU5$)a.Estimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = EuclideanTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") rrs r r EuclideanTransform.from_estimatesBc,,r"c[XUR5Ul[R"[R "UR55(aS$S$)Nz Poor conditioning for estimation)ri_estimate_scalerrrrr{s r rEuclideanTransform._estimatesHs)=)=> vvbhht{{+,, /  r"cURS:Xa1[R"URSURS5$URS:XaURSS2SS24$[ S5e)Nrrvr_rz3Rotation only implemented for 2D and 3D transforms.)rrcrwrrrws r rEuclideanTransform.rotationsl   ! #::dkk$/T1BC C  A %;;rr2A2v& &%E r"cPURSUR2UR4$r}r~rws r rEuclideanTransform.translationrr"c(URX5SL$)aEstimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. Returns ------- success : bool True, if model estimation succeeds. Nrr{s r rEuclideanTransform.estimates,~~c'4//r"rr)rrrrrrrrrrrr rrrrrr rrrrs@r rrs}@OG'+dGG   -/?(? - -D   II00r"rcZ^\rSrSrSrSrS SSSSS.U4SjjjrSr\S5r S r U=r $) SimilarityTransformia Similarity transformation. Has the following form in 2D:: X = a0 * x - b0 * y + a1 = = s * x * cos(rotation) - s * y * sin(rotation) + a1 Y = b0 * x + a0 * y + b1 = = s * x * sin(rotation) + s * y * cos(rotation) + b1 where ``s`` is a scale factor and the homogeneous transformation matrix is:: [[a0 -b0 a1] [b0 a0 b1] [0 0 1 ]] The similarity transformation extends the Euclidean transformation with a single scaling factor in addition to the rotation and translation parameters. The implicit parameters are applied in the following order: 1. Scale; 2. Rotation; 3. Translation. Parameters ---------- matrix : (dim+1, dim+1) array_like, optional Homogeneous transformation matrix. scale : float, optional Scale factor. Implemented only for 2D and 3D. rotation : float, optional Rotation angle, clockwise, as radians. Implemented only for 2D and 3D. For 3D, this is given in ZYX Euler angles. translation : (dim,) array_like, optional x, y[, z] translation parameters. Implemented only for 2D and 3D. dimensionality : int, optional The dimensionality of the transform, corresponding to ``dim`` above. Ignored if `matrix` is not None, and set to ``matrix.shape[0] - 1``. Otherwise, must be one of 2 or 3. Attributes ---------- params : (dim+1, dim+1) array Homogeneous transformation matrix. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transform with an homogeneous transformation matrix: >>> tform = ski.transform.SimilarityTransform(np.diag([2., 3., 1.])) >>> tform.params array([[2., 0., 0.], [0., 3., 0.], [0., 0., 1.]]) Define a transform with parameters: >>> tform = ski.transform.SimilarityTransform( ... rotation=0.2, translation=[1, 2]) >>> np.round(tform.params, 2) array([[ 0.98, -0.2 , 1. ], [ 0.2 , 0.98, 2. ], [ 0. , 0. , 1. ]]) You can estimate a transformation to map between source and destination points: >>> src = np.array([[150, 150], ... [250, 100], ... [150, 200]]) >>> dst = np.array([[200, 200], ... [300, 150], ... [150, 400]]) >>> tform = ski.transform.SimilarityTransform.from_estimate(src, dst) >>> np.allclose(tform.params, [[ 1.79, 0.21, -142.86], ... [-0.21, 1.79, 21.43], ... [ 0. , 0. , 1. ]], atol=0.01) True Apply the transformation to some image data. >>> img = ski.data.astronaut() >>> warped = ski.transform.warp(img, inverse_map=tform.inverse) The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((3, 2)) >>> bad_tform = ski.transform.SimilarityTransform.from_estimate( ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... TN)rhrrrc>[SX#U455nUS:waUb [S5eURX#U4U5 Ub([R"U5(d [ U5SpOUR X45upxUb [U5eUbUOUbUOSnURX4U5nUS;aUSU2SU24==U-ss'[T U]%XS9 g)Nc3(# UHoSLv M g7frrnrs r r/SimilarityTransform.__init__..sK,Jqd,JrrrXr)Nrr) r-r _check_scalerrbrKrrrr) rprrhrrr n_srt_nonerrrs r rSimilarityTransform.__init__sKUk,JKK ?! +   e %.s/,QDy,ra In the future, it will be a ValueError to pass a scalar `scale` value with a ``dimensionality`` > 2 ,and without other implicit parameters to indicate the dimensionality of the transform. Please indicate dimensionality by passing a vector of suitable length to `scale`.r) stacklevel)rrbr7warningswarn FutureWarning)rprh other_paramsrs r r SimilarityTransform._check_scalesN Y &%-r{{5?Q?Q  /,/ / / MM1   0r"cLURS:Xa=[R"[RR UR 55$URS:Xa=[R "[RR UR 55$[S5e)Nrrz(Scale is only implemented for 2D and 3D.)rrrrQrRrcbrtrrws r rhSimilarityTransform.scalesl   ! #77299==56 6  A %77299==56 6%&PQ Qr"rnr) rrrrrrrrrrhrrrs@r rrsRrjO#G#G#GJ RRr"rc^\rSrSrSrS SS.Sjjr\SU4Sjj5rSSjrSr \S S j5r \ S 5r \ SS j5rS rU=r$)PolynomialTransformia2D polynomial transformation. Has the following form:: X = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) Y = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) Parameters ---------- params : (2, N) array_like, optional Polynomial coefficients where `N * 2 = (order + 1) * (order + 2)`. So, a_ji is defined in `params[0, :]` and b_ji in `params[1, :]`. dimensionality : int, optional Must have value 2 (the default) for polynomial transforms. Attributes ---------- params : (2, N) array Polynomial coefficients where `N * 2 = (order + 1) * (order + 2)`. So, a_ji is defined in `params[0, :]` and b_ji in `params[1, :]`. Examples -------- >>> import numpy as np >>> import skimage as ski Define a transformation by estimation: >>> src = [[-12.3705, -10.5075], ... [-10.7865, 15.4305], ... [8.6985, 10.8675], ... [11.4975, -9.5715], ... [7.8435, 7.4835], ... [-5.3325, 6.5025], ... [6.7905, -6.3765], ... [-6.1695, -0.8235]] >>> dst = [[0, 0], ... [0, 5800], ... [4900, 5800], ... [4900, 0], ... [4479, 4580], ... [1176, 3660], ... [3754, 790], ... [1024, 1931]] >>> tform = ski.transform.PolynomialTransform.from_estimate(src, dst) Calling the transform applies the transformation to the points: >>> pts = tform(src) >>> np.allclose(pts, [[ 7.54, 12.27], ... [ 2.98, 5796.95], ... [4870.44, 5766.59], ... [4889.72, -6.72], ... [4515.62, 4617.5 ], ... [1183.25, 3694. ], ... [3767.57, 800.53], ... [ 998.02, 1881.97]], atol=0.01) True NrcUcSnOUS:wa [S5e[R"Uc/SQ/SQ/OU5UlURRS:XdURRSS:wa [ S5eg)Nrz2Polynomial transforms are only implemented for 2D.)rrrrarnrz.Transformation parameters must be shape (2, N))rrr>rr*r)rprrs r rPolynomialTransform.__init__ s|  !N q %D hh 95VT ;;   "dkk&7&7&:a&?MN N'@r"c$>[TU]XX45$)a Estimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. The transformation is defined as:: X = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) Y = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) These equations can be transformed to the following form:: 0 = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) - X 0 = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) - Y which exist for each set of corresponding points, so we have a set of N * 2 equations. The coefficients appear linearly so we can write A x = 0, where:: A = [[1 x y x**2 x*y y**2 ... 0 ... 0 -X] [0 ... 0 1 x y x**2 x*y y**2 -Y] ... ... ] x.T = [a00 a10 a11 a20 a21 a22 ... ann b00 b10 b11 b20 b21 b22 ... bnn c3] In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3. Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalized, square-rooted, then built into a diagonal matrix, by which A is multiplied. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. order : int, optional Polynomial order (number of coefficients is order + 1). weights : (N,) array_like, optional Relative weight values for each pair of points. Returns ------- tf : Self or ``FailedEstimation`` An instance of the transformation 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 tf = PolynomialTransform.from_estimate(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") r)rrXrYorderr"rs r r!PolynomialTransform.from_estimate sHw$Su>>r"c [R"U5n[R"U5nUSS2S4nUSS2S4nUSS2S4nUSS2S4nURSn [U5nUS-US--n [R"U S-U S-45n Sn [ US-5HGn [ U S-5H2nX]U- -Xn--U SU 2U 4'X]U- -Xn--XS2XS--4'U S- n M4 MI X{SU 2S4'XU S2S4'Uc$[R RU 5u nnO[R"U5n[R"[R"[R"U[R"U5- 5S55n[R RUU -5u nnUSSS24*US- nURSU S-45Ul g)Nrrrrr%)rrOr*r r&rrQrSrVr(rrTrr)rprXrYrr"xsysxdydrowsurapidxjrrrdr-rs r rPolynomialTransform._estimatea sjjojjo AY AY AY AYyy|E" QY519 % HHdQhA& 'uqy!A1q5\!#A!6%4%+*,Q-"%*?%Q&' "" %4%) $%)  ?iimmA&GAq!jj)G"&&/(A BAFGAiimmAE*GAq!BG*qy(nnaa[1 r"c N[R"U5nUSS2S4nUSS2S4n[URR 55n[ S[ R"SSSU- -- 5-S- 5n[R"UR5nSn[US-5Hwn[US-5Hbn USS2S4==URSU4X(U - --X9--- ss'USS2S4==URSU4X(U - --X9--- ss'US- nMd My U$)zApply forward transformation. Parameters ---------- coords : (N, 2) array_like source coordinates Returns ------- coords : (N, 2) array Transformed coordinates. Nrr rr) rrOrKrravelrrcrr&r*r) rprqxyrrrYrrrs r rrPolynomialTransform.__call__ sF# 1a4L 1a4L  !!# $R$))AQU O449:hhv||$uqy!A1q5\AqD T[[D1Aa%L@14GG AqD T[[D1Aa%L@14GG  ""  r"cU"SUS9$)rNr~rnrs r rPolynomialTransform.identity s $~>>r"c[S5e)NzThere is no explicit way to do the inverse polynomial transformation. Instead, estimate the inverse transformation parameters by exchanging source and destination coordinates,then apply the forward transformation.)rrws r rxPolynomialTransform.inverse s! 5  r"c*URXX45SL$)aEstimate the transformation from a set of corresponding points. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. The transformation is defined as:: X = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) Y = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) These equations can be transformed to the following form:: 0 = sum[j=0:order]( sum[i=0:j]( a_ji * x**(j - i) * y**i )) - X 0 = sum[j=0:order]( sum[i=0:j]( b_ji * x**(j - i) * y**i )) - Y which exist for each set of corresponding points, so we have a set of N * 2 equations. The coefficients appear linearly so we can write A x = 0, where:: A = [[1 x y x**2 x*y y**2 ... 0 ... 0 -X] [0 ... 0 1 x y x**2 x*y y**2 -Y] ... ... ] x.T = [a00 a10 a11 a20 a21 a22 ... ann b00 b10 b11 b20 b21 b22 ... bnn c3] In case of total least-squares the solution of this homogeneous system of equations is the right singular vector of A which corresponds to the smallest singular value normed by the coefficient c3. Weights can be applied to each pair of corresponding points to indicate, particularly in an overdetermined system, if point pairs have higher or lower confidence or uncertainties associated with them. From the matrix treatment of least squares problems, these weight values are normalized, square-rooted, then built into a diagonal matrix, by which A is multiplied. Parameters ---------- src : (N, 2) array_like Source coordinates. dst : (N, 2) array_like Destination coordinates. order : int, optional Polynomial order (number of coefficients is order + 1). weights : (N,) array_like, optional Relative weight values for each pair of points. Returns ------- success : bool True, if model estimation succeeds. Nr)rprXrYrr"s r rPolynomialTransform.estimate sv~~c74??r"rr)rN)rrrrrrrrrrrrrrxr rrrrs@r rrsw:x Od OC?C?J'R>??"  :@:@r"r) euclidean similarityrzpiecewise-affine projective fundamental essential polynomialcUR5nU[;a[SUS35e[UR"X/UQ70UD6$)a Estimate 2D geometric transformation parameters. You can determine the over-, well- and under-determined parameters with the total least-squares method. Number of source and destination coordinates must match. Parameters ---------- ttype : {'euclidean', similarity', 'affine', 'piecewise-affine', 'projective', 'polynomial'} Type of transform. kwargs : array_like or int Function parameters (src, dst, n, angle):: NAME / TTYPE FUNCTION PARAMETERS 'euclidean' `src, `dst` 'similarity' `src, `dst` 'affine' `src, `dst` 'piecewise-affine' `src, `dst` 'projective' `src, `dst` 'polynomial' `src, `dst`, `order` (polynomial order, default order is 2) Also see examples below. Returns ------- tf : :class:`_GeometricTransform` or ``FailedEstimation`` An instance of the requested transformation if the estimation 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 tf = estimate_transform(...) if not tf: raise RuntimeError(f"Failed estimation: {tf}") Examples -------- >>> import numpy as np >>> import skimage as ski >>> # estimate transformation parameters >>> src = np.array([0, 0, 10, 10]).reshape((2, 2)) >>> dst = np.array([12, 14, 1, -20]).reshape((2, 2)) >>> tform = ski.transform.estimate_transform('similarity', src, dst) >>> np.allclose(tform.inverse(tform(src)), src) True >>> # warp image using the estimated transformation >>> image = ski.data.camera() >>> ski.transform.warp(image, inverse_map=tform.inverse) # doctest: +SKIP >>> # create transformation with explicit parameters >>> tform2 = ski.transform.SimilarityTransform(scale=1.1, rotation=1, ... translation=(10, 20)) >>> # unite transformations, applied in order from left to right >>> tform3 = tform + tform2 >>> np.allclose(tform3(src), tform2(tform(src))) True The estimation can fail - for example, if 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 (applying ``bool()`` >>> # gives ``True``): >>> if tform: ... print("Estimation succeeded.") Estimation succeeded. >>> # Not so for a degenerate transform with identical points. >>> bad_src = np.ones((2, 2)) >>> bad_tform = ski.transform.estimate_transform('similarity', ... bad_src, dst) >>> if not bad_tform: ... print("Estimation failed.") Estimation failed. Trying to use this failed estimation transform result will give a suitable error: >>> bad_tform.params # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... FailedEstimationAccessError: No attribute "params" for failed estimation ... zthe transformation type 'z' is not implemented)r+ TRANSFORMSrr)ttyperXrYrrs r estimate_transformr sN~ KKME J5eWrs] #/ HV60D:(M `c>#c>LM4(+4(nm0!2m0` R09R0jC9+C9L !cI)cI!cILe02e0P,A0,A0H!uR,uR!uRpl@-l@` $%0%-)%  cFL/r"