a6d8dZddlmZddlmZddlZddlmZ ddl m Z ddl mZdd lmZd d lmZmZd Zd dddddejddZdZddddejddZdS)z.TV-L1 optical flow algorithm implementation. )partial)combinations_with_replacementN)ndimage)gaussian)_supported_float_type)warp)coarse_to_fineget_warp_pointsc !|j!tj!fd|jDddd} d|jz } d} ||z} | |z } ||jz}|x}}tj|jf|jz!}tj|j|jf|jz!}tdg|jz}tdg|jz}tdg|jdz z}t|D]p}|r"tj |d g|jd gzz}t|t| |d }tj tj|}||zd }d ||d k<||z ||zd z }t|D]}|||zd z}t!|| |zk}|}|dd|fxx|||dd|fz||z zcc<|}| tj||z}|dd|fxx||dd|fzzcc<|}t|jD]}||d <t| D]}t|jD]^}||d <td d||d z<tj||||t)|<td||d z<_tj|dzd tjdf}|| z}|dz }||xx| |zzcc<||xx|zcc<||d  } t|jD]}||d <td d||dz<td d||<| t)|xx|t)|z cc<td||dz<td||<||| z||<||z}||z|krn|}r|S)uTV-L1 solver for optical flow estimation. Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first gray scale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second gray scale 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. c<g|]}tj|Sdtypenparange.0nrs Blib/python3.11/site-packages/skimage/registration/_optical_flow.py z_tvl1..789991E222999ijTindexingsparseg?rrNr edgemoderaxis.g?)rrmeshgridshapendimsizezerosslicerangendi median_filterr r arraygradientsumabssigncopydifftuplesqrtnewaxis)"reference_image moving_imageflow0 attachment tightnessnum_warpnum_itertol prefiltergriddt reg_num_iterf0f1 flow_current flow_previousgprojs_gs_ps_d_ image1_warpgradNIrho_0rhoidxflow_auxiliarysrhoaxnormdrs" @r_tvl1r[s J  !E ;9999"1"7999 $T 3 3 3D # #BL i B iB? C#((L= /&(?+@@NNNA 8_)?+?A%+,38 : : :D ;;/AF "C ;;/DI %C ;;/TYq[ )C 8__?%?%  O,\./S?3G1#3M-MOOL<|)L)L &((( x K00114i__Q  27 o- 1D0I0I!0L0LLx, @, @A4 ,11!444Cc((b2g%C)N 111c6 " " "c#htAAAsF|&;BsG&C C " " "$CC)))D 111c6 " " "d43<&7 7 " " "*..00L_122 @ @A|,,@@A#O$89900!#A$)!RLLBqD (* S0A(K(K(K%** $)$KKBqD 7AF<<??33BJODDBJDBJDIIIa'IIIIII%IIIcq)))A#O$899..!#A$)!RLLBqD "'4..B%** eCjj)99 $)$KKBqD "'++B(6s(;a(?L%%/@ @6 % - ' , , . . 4 4 E$ rg333333? g-C6?F)r=r>r?r@rArBrc tt||||||} tj|t |krd|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 gray scale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second gray scale 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:`\tau` 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>r?r@rArBdtype=. is not supported. Try 'float32' or 'float64.'r)rr[rrr ValueErrorr ) r:r;r=r>r?r@rArBrsolvermsgs roptical_flow_tvl1reszZUz(8h 333F x/6666LuLLLoo /<u M M MMrc|j|j}d|zdz}|r!||dz fz} tt| d} n ttj||fzd} |} t j|j||fz} t j|j|fz} t j fd|jDd d d }t|D]}|rt j | d |d zz} t|t|| d}t jt j|d}|| zd|z|z }t#t|dD]-\}}| ||||zx| d||f<| d||f<.t|D]}| |||z| d|f<t%t j| dk}t j|| |<d| |<t jt j| | |d} | S)aIterative Lucas-Kanade (iLK) solver for optical flow estimation. Parameters ---------- reference_image : ndarray, shape (M, N[, P[, ...]]) The first gray scale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second gray scale 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*r#rc<g|]}tj|Srrrs rrz_ilk..rrrTr)r )r r!r"rr%.g+=)rr)rgaussian_filterr.uniform_filterrr+r(r'r-r/r r stackr1r2rr3linalgdeteyemoveaxissolve)r:r;r<radiusr?rrBr)r*ri filter_funcflowAbrCrOmoving_image_warprQ error_imageijrUrs @r_ilkr|s:  !E  D v:>D-q|#oUJJJ c0tth#+---  D &$5UCCCA &$1???A ;9999"1"7999 $T 3 3 3D8__;;  A$T54%<+?@@D tT/J/J&,...x $566Q???t ((a(00()+<= 2%++qAA I IDAq*5+d1gQ6G*H*H HAc1aiL1S!QY<<t ; ;A# DGk$9::Ac1fII")--""##e+E***##{29??1a00$:: Kr)rsr?rrBrctt||||}tj|t |krd|d}t |t ||||S)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 gray scale image of the sequence. moving_image : ndarray, shape (M, N[, P[, ...]]) The second gray scale 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) )rsr?rrBr`rar)rr|rrrrbr ) r:r;rsr?rrBrrcrds roptical_flow_ilkr6suFT&8h(***F x/6666LuLLLoo /<u M M MMr)__doc__ functoolsr itertoolsrnumpyrscipyrr._shared.filtersrrk _shared.utilsr transformr _optical_flow_utilsr r r[float32rer|rrrrs@333333 999999111111@@@@@@@@{{{@"$sQ%rzUNUNUNUNUNpLLL`U$BJJNJNJNJNJNJNJNr