+ Ai8Rt^RIHt^RIHt^RIt^RIHt ^RI H t ^RI Ht^RIHt^RIHtHtR tR ^R R R ^R^ RRRRR]P*/RltRtR^R ^ RRRRR]P*/RltR#)z,TV-L1 optical flow algorithm implementation.)partial)combinations_with_replacementN)ndimage)gaussian)_supported_float_type)warp)_coarse_to_fine_get_warp_pointsc  VPp \P!VPU u.uFp \P!WR7NK up RRRR/p RVP , p ^p W4,pW, pWpP ,pT;pp\P!VP 3VP,V R7p\P!VP VP 3VP,V R7p\R4.VP ,p\R4.VP ,p\R4.VP ^, ,p\V4EFpV'd2\P!V^.VP ^.,,4p\V\V V4RR 7p\P!\P!V44pVV,P!^4p^VV^8H&VV, VV,P!^4, p\V4EFpVVV,P!^4,p\#V4VV,8*pTpVR V3;;,VV,VR V3,,VV,, ,uu&V(pV\P$!VV,4,pVR V3;;,VVR V3,,,uu&VP'4p\VP 4EFpVV^&\V 4EFp\VP 4F^p V V^&\^R4VV ^,&\P(!VV,V R 7V\+V4&\R4VV ^,&K` \P,!V^,P!^44\P.R 3,p!V!V,p!V!R , p!VV;;,V V,,uu&VV;;,V!,uu&VV,P!^4)p"\VP 4F~p V V^&\^R4VV ^,&\^R4VV &V"\+V4;;,V\+V4,, uu&\R4VV ^,&\R4VV &K VV,V",VV&EK EK EK VV,pVV,P!4V8dV#TpEK V#uup i)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. dtypeindexingijsparseTg?Nedgemode:NNNaxis.g?)r npmeshgridshapearangendimsizezerosslicerangendi median_filterrr arraygradientsumabssigncopydifftuplesqrtnewaxis)#reference_image moving_imageflow0 attachment tightnessnum_warpnum_itertol prefilterr ngriddt reg_num_iterf0f1 flow_current flow_previousgprojs_gs_ps_d_ image1_warpgradNIrho_0rhoidxflow_auxiliarysrhoaxnormds#&&&&&&&&& `/var/www/html/photoedit/myenv/lib/python3.14/site-packages/skimage/registration/_optical_flow.py_tvl1rNs\  ! !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 Ds T<r.r/g333333?r0r1r2g-C6?r3Fr c \\VVVVVVR7p \P!V4\ V48wdRV R2p \ V 4h\ WWR7#)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) )r.r/r0r1r2r3dtype=. is not supported. Try 'float32' or 'float64.'r )rrNrr r ValueErrorr) r+r,r.r/r0r1r2r3r solvermsgs &&$$$$$$$ rMoptical_flow_tvl1rUsbj  F xx/66ugKLo ?& NNc VPpVPp^V,^,p V'd$W^, 3,p \\V RR7p M#\\P W3,RR7p Tp \ P!VPW3,VR7p \ P!VPV^3,VR7p\ P!VPUu.uFp\ P!WR7NK upRRRR/p\V4EFpV'd&\P!V RVR,,4p \V\VV 4R R 7p\ P!\ P !V4^R 7pVV ,P#^R 7V,V, p\%\V4^4F1wppV !VV,VV,,4;V R VV3&V R VV3&K3 \V4FpV !VV,V,4VR V^3&K! \'\ P(P+V 44R 8p\ P,!WR7V V&^VV&\ P.!\ P(P1W4R,V^4p EK V #uupi)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. mirror)sigmar)rrr r rrTrrr.g+=))).)r rrgaussian_filterruniform_filterrrrrrrr rr stackr"r#rr$linalgdeteyemoveaxissolve)r+r,r-radiusr0rr3r rrrY filter_funcflowAbr4r5rAmoving_image_warprC error_imageijrGs&&&&&&& rM_ilkrn sO8  ! !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= Ds, Krerc\\W#WER7p\P!V4\ V48wdRV R2p\ V4h\ WWvR7#)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) )rer0rr3rPrQr )rrnrr rrRr) r+r,rer0rr3r rSrTs &&$$$$$ rMoptical_flow_ilkrp[sTT VF xx/66ugKLo ?& NNrV)__doc__ functoolsr itertoolsrnumpyrscipyrr_shared.filtersrr] _shared.utilsr transformr_optical_flow_utilsrr rNfloat32rUrnrprVrMr|s23 91BTncO cO  cO  cOcO cOcO **cOLL^RO RO  RO  RORO **ROrV