9i8SrSSKJr SSKJr SSKrSSKJr SSK J r SSK Jr SS KJr S S KJrJr S rS SSSSS\R*S.SjrSrSSSS\R*S.Sjrg)z,TV-L1 optical flow algorithm implementation.)partial)combinations_with_replacementN)ndimage)gaussian)_supported_float_type)warp)_coarse_to_fine_get_warp_pointsc URn [R"URV s/sHn [R"XS9PM sn SSS.6n SUR - n Sn X4-nX- nXpR -nU=nn[R"UR 4UR-U S9n[R"UR UR 4UR-U S9n[S5/UR -n[S5/UR -n[S5/UR S- -n[U5GHnU(a)[R"US/UR S /--5n[U[U U5S S 9n[R"[R"U55nUU-R!S 5nSUUS :H'UU- UU-R!S 5- n[U5GH@nUUU-R!S 5-n[#U5UU-:*nUnUSS2U4==UUUSS2U4-UU- -ss'U)nU[R$"UU5-nUSS2U4==UUSS2U4--ss'UR'5n[UR 5GHnUUS '[U 5GHqn[UR 5HOn U US '[S S 5UU S-'[R("UUU S9U[+U5'[S5UU S-'MQ [R,"US-R!S 55[R.S4n!U!U-n!U!S- n!UU==U U--ss'UU==U!-ss'UUR!S 5*n"[UR 5Hjn U US'[S S 5UU S-'[SS5UU 'U"[+U5==U[+U5- ss'[S5UU S-'[S5UU 'Ml UUU"-UU'GMt GM GMC UU-nUU-R!5U:a U$UnGM U$s sn f)u>TV-L1 solver for optical flow estimation. Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first grayscale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second grayscale image of the sequence. flow0 : ndarray, shape (image0.ndim, M, N[, P[, ...]]) Initialization for the vector field. attachment : float Attachment parameter. The smaller this parameter is, the smoother is the solutions. tightness : float Tightness parameter. It should have a small value in order to maintain attachment and regularization parts in correspondence. num_warp : int Number of times moving_image is warped. num_iter : int Number of fixed point iteration. tol : float Tolerance used as stopping criterion based on the L² distance between two consecutive values of (u, v). prefilter : bool Whether to prefilter the estimated optical flow before each image warp. Returns ------- flow : ndarray, shape (image0.ndim, M, N[, P[, ...]]) The estimated optical flow components for each axis. dtypeijTindexingsparseg?rNr edgemoderaxis.g?)rnpmeshgridshapearangendimsizezerosslicerangendi median_filterr r arraygradientsumabssigncopydifftuplesqrtnewaxis)#reference_image moving_imageflow0 attachment tightnessnum_warpnum_itertol prefilterrngriddt reg_num_iterf0f1 flow_current flow_previousgprojs_gs_ps_d_ image1_warpgradNIrho_0rhoidxflow_auxiliarysrhoaxnormds# b/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/skimage/registration/_optical_flow.py_tvl1rSs|\  ! !E ;;-<-B-B C-B"))A #-B C D ## #BL  B B  C#((L= /&&(?+@+@@NA 88           D d    C d    C d   Q C8_ ,,qcO$8$8A3$>>L *4>V xx K01Tk  q !27 o- 1D0I0I!0LLxA4,.33A66Cc(b2g%C)N 1c6 "c#haf&=3&G G "$CC))D 1c6 "dT!S&\&9 9 "*..0L_112A|,A#O$8$89!#A&+ArlBF (* S0A(K%* &+DkBF : 77AqD::a=1"**c/BDBJDCKDIa'II%Icq))A#O$8$89!#A&+ArlBF "'4.B%* eCj)99 &+DkBF "'+B :)7s(;a(?L%/-3%!Z % M ) . . 03 6  % AD I DsQg333333? g-C6?F)r3r4r5r6r7r8rc [[UUUUUUS9n [R"U5[ U5:waSUS3n [ U 5e[ XXS9$)u Coarse to fine optical flow estimator. The TV-L1 solver is applied at each level of the image pyramid. TV-L1 is a popular algorithm for optical flow estimation introduced by Zack et al. [1]_, improved in [2]_ and detailed in [3]_. Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first grayscale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second grayscale image of the sequence. attachment : float, optional Attachment parameter (:math:`\lambda` in [1]_). The smaller this parameter is, the smoother the returned result will be. tightness : float, optional Tightness parameter (:math:`\theta` in [1]_). It should have a small value in order to maintain attachment and regularization parts in correspondence. num_warp : int, optional Number of times moving_image is warped. num_iter : int, optional Number of fixed point iteration. tol : float, optional Tolerance used as stopping criterion based on the L² distance between two consecutive values of (u, v). prefilter : bool, optional Whether to prefilter the estimated optical flow before each image warp. When True, a median filter with window size 3 along each axis is applied. This helps to remove potential outliers. dtype : dtype, optional Output data type: must be floating point. Single precision provides good results and saves memory usage and computation time compared to double precision. Returns ------- flow : ndarray, shape (image0.ndim, M, N[, P[, ...]]) The estimated optical flow components for each axis. Notes ----- Color images are not supported. References ---------- .. [1] Zach, C., Pock, T., & Bischof, H. (2007, September). A duality based approach for realtime TV-L 1 optical flow. In Joint pattern recognition symposium (pp. 214-223). Springer, Berlin, Heidelberg. :DOI:`10.1007/978-3-540-74936-3_22` .. [2] Wedel, A., Pock, T., Zach, C., Bischof, H., & Cremers, D. (2009). An improved algorithm for TV-L 1 optical flow. In Statistical and geometrical approaches to visual motion analysis (pp. 23-45). Springer, Berlin, Heidelberg. :DOI:`10.1007/978-3-642-03061-1_2` .. [3] Pérez, J. S., Meinhardt-Llopis, E., & Facciolo, G. (2013). TV-L1 optical flow estimation. Image Processing On Line, 2013, 137-150. :DOI:`10.5201/ipol.2013.26` Examples -------- >>> from skimage.color import rgb2gray >>> from skimage.data import stereo_motorcycle >>> from skimage.registration import optical_flow_tvl1 >>> image0, image1, disp = stereo_motorcycle() >>> # --- Convert the images to gray level: color is not supported. >>> image0 = rgb2gray(image0) >>> image1 = rgb2gray(image1) >>> flow = optical_flow_tvl1(image1, image0) )r3r4r5r6r7r8dtype=. is not supported. Try 'float32' or 'float64.'r)rrSrrr ValueErrorr ) r0r1r3r4r5r6r7r8rsolvermsgs rRoptical_flow_tvl1r]sbj  F xx/66ugKLo ?& NNc URnURnSU-S-n U(aXS- 4-n [[U SS9n O[[R X4-SS9n Un [ R"URX4-US9n [ R"URUS4-US9n[ R"URVs/sHn[ R"XS9PM snSS S .6n[U5GHanU(a[R"U S US --5n [U[UU 5S S9n[ R"[ R "U5SS9nUU -R#SS9U-U- n[%[U5S5H%unnU "UUUU-5=U SUU4'U SUU4'M' [U5HnU "UUU-5USUS4'M ['[ R(R+U 55S:n[ R,"XS9U U'SUU'[ R."[ R(R1X5SUS5n GMd U $s snf)aIterative Lucas-Kanade (iLK) solver for optical flow estimation. Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first grayscale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second grayscale image of the sequence. flow0 : ndarray, shape (reference_image.ndim, M, N[, P[, ...]]) Initialization for the vector field. radius : int Radius of the window considered around each pixel. num_warp : int Number of times moving_image is warped. gaussian : bool if True, a gaussian kernel is used for the local integration. Otherwise, a uniform kernel is used. prefilter : bool Whether to prefilter the estimated optical flow before each image warp. This helps to remove potential outliers. Returns ------- flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]]) The estimated optical flow components for each axis. rr mirror)sigmar)r rrrTr)r )rrrrr.g+=).r)rrrgaussian_filterr$uniform_filterrr!rrrr#r%r r stackr'r(rr)linalgdeteyemoveaxissolve)r0r1r2radiusr5rr8rrr rb filter_funcflowAbr9r:rFmoving_image_warprH error_imageijrLs rR_ilkrt sC8  ! !E   D v:>Dq{"oUJ c00tg~HU D &&$5UCA &&$2%@A ;;-<-B-B C-B"))A #-B C D 8_ $$T4$++=>D *46V xx $56Q?d{''Q'//ADUU 2%+qADAq*5d1gQ6G*H HAc1aiL1S!QY<BtA&tAw'<=Ac1aiL"))--"#e+*##{{299??108$B/2 K= DsI)rkr5rr8rc[[X#XES9n[R"U5[ U5:waSUS3n[ U5e[ XXvS9$)a] Coarse to fine optical flow estimator. The iterative Lucas-Kanade (iLK) solver is applied at each level of the image pyramid. iLK [1]_ is a fast and robust alternative to TVL1 algorithm although less accurate for rendering flat surfaces and object boundaries (see [2]_). Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first grayscale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second grayscale image of the sequence. radius : int, optional Radius of the window considered around each pixel. num_warp : int, optional Number of times moving_image is warped. gaussian : bool, optional If True, a Gaussian kernel is used for the local integration. Otherwise, a uniform kernel is used. prefilter : bool, optional Whether to prefilter the estimated optical flow before each image warp. When True, a median filter with window size 3 along each axis is applied. This helps to remove potential outliers. dtype : dtype, optional Output data type: must be floating point. Single precision provides good results and saves memory usage and computation time compared to double precision. Returns ------- flow : ndarray, shape (reference_image.ndim, M, N[, P[, ...]]) The estimated optical flow components for each axis. Notes ----- - The implemented algorithm is described in **Table2** of [1]_. - Color images are not supported. References ---------- .. [1] Le Besnerais, G., & Champagnat, F. (2005, September). Dense optical flow by iterative local window registration. In IEEE International Conference on Image Processing 2005 (Vol. 1, pp. I-137). IEEE. :DOI:`10.1109/ICIP.2005.1529706` .. [2] Plyer, A., Le Besnerais, G., & Champagnat, F. (2016). Massively parallel Lucas Kanade optical flow for real-time video processing applications. Journal of Real-Time Image Processing, 11(4), 713-730. :DOI:`10.1007/s11554-014-0423-0` Examples -------- >>> from skimage.color import rgb2gray >>> from skimage.data import stereo_motorcycle >>> from skimage.registration import optical_flow_ilk >>> reference_image, moving_image, disp = stereo_motorcycle() >>> # --- Convert the images to gray level: color is not supported. >>> reference_image = rgb2gray(reference_image) >>> moving_image = rgb2gray(moving_image) >>> flow = optical_flow_ilk(moving_image, reference_image) )rkr5rr8rXrYr)rrtrrrrZr ) r0r1rkr5rr8rr[r\s rRoptical_flow_ilkrw[sTT VF xx/66ugKLo ?& NNr^)__doc__ functoolsr itertoolsrnumpyrscipyrr$_shared.filtersrrc _shared.utilsr transformr _optical_flow_utilsr r rSfloat32r]rtrwr^rRrsm23 91BTv    **cOLLf   **ROr^