|h8dZddlmZddlmZddlZddlmZ ddl m Z ddl mZdd lmZd d lmZmZd Zd dddddej*ddZdZddddej*ddZy)z,TV-L1 optical flow algorithm implementation.)partial)combinations_with_replacementN)ndimage)gaussian)_supported_float_type)warp)_coarse_to_fine_get_warp_pointsc |j} tj|jD cgc]} tj| | c} ddd} d|j z } d} ||z}| |z }||j z}|x}}tj|j f|jz| }tj|j |j f|jz| }tdg|j z}tdg|j z}tdg|j dz z}t|D] }|r(tj|dg|j d gzz}t|t| |d }tjtj|}||zj!d }d||d k(<||z ||zj!d z }t|D]7}|||zj!d z}t#|||zk}|}|dd|fxx|||dd|fz||z zcc<|}|tj$||z}|dd|fxx||dd|fzzcc<|j'}t|j D]}||d <t| D]m}t|j D]P} | |d <td d || dz<tj(||| |t+|<td|| dz<Rtj,|dzj!d tj.df}!|!|z}!|!dz }!||xx| |zzcc<||xx|!zcc<||j!d  }"t|j D]i} | |d<td d || dz<tdd|| <|"t+|xx|t+|z cc<td|| dz<td|| <k|||"z||<p:||z}||zj!|kr|S|} |Scc} w)uTV-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# a/var/www/html/test/engine/venv/lib/python3.12/site-packages/skimage/registration/_optical_flow.py_tvl1rSs\  ! !E ;;-<-B-B C"))AU # C D ## #BL i B iB?  C#((L= /&&(?+@+@@NA 88           D d    C d    C d   Q C8_@% ,,qcO$8$8A3$>>L *4>V xx K01Tk  q !27 o- 1D0I0I!0LLx+ @A4,.33A66Cc(b2g%C)N 1c6 "c#haf&=3&G G "$CC))D 1c6 "dT!S&\&9 9 "*..0L_112 @A|,@A#O$8$892!#A&+ArlBF (* S0A(K%* &+DkBF 2 77AqD::a=1"**c/BDBJDCKDIa'II%Icq))A#O$8$89.!#A&+ArlBF "'4.B%* eCj)99 &+DkBF "'+B .)7s(;a(?L%/@ @%+ @Z % M ) . . 03 6  % A@%D I DsQg333333? g-C6?F)r3r4r5r6r7r8rc tt||||||} tj|t |k7rd|d} t | t ||| |S)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]sfj  F xx/66ugKLo ?L& NNc |j}|j}d|zdz} |r|| dz fz} tt| d} n ttj || fzd} |} t j|j||fz|} t j|j|dfz|}t j|jDcgc]}t j||c}dd d }t|D]`}|rt j| d |d zz} t|t|| d }t jt j |d}|| zj#d|z|z }t%t|dD]$\}}| ||||zx| d||f<| d||f<&t|D]}| |||z|d|df<t't j(j+| dk}t j,||| |<d||<t j.t j(j1| |d|d} c| Scc}w)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 s[8  ! !E   D v:>Dq{"oUJ c00ttg~HU D &&$5UCA &&$2%@A ;;-<-B-B C"))AU # C D 8_C $$T4$++=>D *46V xx $56Q?d{''Q'//ADUU 2%+qA IDAq*5d1gQ6G*H HAc1aiL1S!QY< It >A&tAw'<=Ac1aiL >"))--"#e+E*##{{299??1a08$B/C2 K= Ds I!)rkr5rr8rctt||||}tj|t |k7rd|d}t |t ||||S)a9 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[s\T VhYF xx/66ugKLo ?L& NNr^)__doc__ functoolsr itertoolsrnumpyrscipyrr$_shared.filtersrrc _shared.utilsr transformr _optical_flow_utilsr r rSfloat32r]rtrwr^rRrsm23 91BTv    **cOLLf   **ROr^