U ?h8@sdZddlmZddlmZddlZddlmZ ddl m Z ddl mZdd lmZd d lmZmZd d ZddddddejdddZddZddddejdddZdS)z.TV-L1 optical flow algorithm implementation. )partial)combinations_with_replacementN)ndimage)gaussian)_supported_float_type)warp)coarse_to_fineget_warp_pointsc ! s|jtjfdd|jDddd} d|j} d} ||} | |} ||j9}|}}tj|jf|jd}tj|j|jf|jd}td g|j}td g|j}td g|jd}t|D]}|rt |d g|jd g}t |t | |d d }t t|}||d}d ||dk<||||d}t|D]}|||d}t|| |k}|}|d d |f|||d d |f||8<|}| t||}|d d |f||d d |f8<|}t|jD]Z}||d<t| D]@}t|jD]J}||d<tdd||d <tj|||d|t|<td ||d <q t|ddtjdf}|| 9}|d7}||| |8<|||<||d } t|jD]f}||d <tdd||d<td d ||<| t||t|7<td ||d<td ||<q||| ||<qqqH||8}|||kr|q|}q|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. csg|]}tj|dqSdtypenpZarange.0nr T/var/www/html/venv/lib/python3.8/site-packages/skimage/registration/_optical_flow.py 7sz_tvl1..ijTZindexingsparseg?rr Nr edgemoderZaxis.g?)rrmeshgridshapendimsizezerosslicerangendi median_filterrr arraygradientsumabssigncopydifftuplesqrtZnewaxis)!reference_image moving_imageflow0 attachment tightnessnum_warpnum_itertol prefiltergriddtZ reg_num_iterZf0f1Z flow_currentZ flow_previousgZprojZs_gZs_pZs_d_Z image1_warpgradZNIZrho_0rhoidxZflow_auxiliaryZsrhoZaxZnormdrr r_tvl1s%    4(rDg333333? g-C6?F)r5r6r7r8r9r:rc CsLtt||||||d} t|t|kr>> 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) )r5r6r7r8r9r:dtype=. is not supported. Try 'float32' or 'float64.'r )rrDrrr ValueErrorr ) r2r3r5r6r7r8r9r:rsolvermsgrrroptical_flow_tvl1sM rMcs|j|j}d|d}|r:||df} tt| dd} nttj||fdd} |} tj|j||fd} tj|j|fd} tj fdd |jDd d d }t |D]}|rt | d |d} t |t || dd}tjt|dd}|| jdd||}tt |dD]6\}}| ||||| d||f<| d||f<qt |D]}| |||| d|f<qXttj| dk}tj|d| |<d| |<ttj| | |d} q| 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 Zmirror)sigmar)r#rr csg|]}tj|dqSr rrr rrrsz_ilk..rTr)r )rrrrr.g+=)rr"rgaussian_filterr'Zuniform_filterrr$r!r r&r(rr stackr*r+rr,ZlinalgZdeteyeZmoveaxisZsolve)r2r3r4radiusr7rr:r"r#rOZ filter_funcZflowAbr;r?Zmoving_image_warpr@Z error_imageijrBrr r_ilksN  0 rX)rSr7rr:rc CsHtt||||d}t|t|kr8d|d}t|t||||dS)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) )rSr7rr:rHrIr )rrXrrrrJr ) r2r3rSr7rr:rrKrLrrroptical_flow_ilk6sC  rZ)__doc__ functoolsr itertoolsrnumpyrZscipyrr'Z_shared.filtersrrPZ _shared.utilsrZ transformrZ_optical_flow_utilsr r rDZfloat32rMrXrZrrrrs2       XP