



"""simple docstring"""


from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve

def 					_lowerCAmelCase (  lowercase_						,      lowercase_						,      lowercase_		):
						UpperCAmelCase			 =					np.stack((horizontal_flow, vertical_flow)						,      2		)

						# Create a grid of all pixel coordinates and subtract the flow to get the
						# target pixels coordinates
						UpperCAmelCase			 =					np.stack(
						    np.meshgrid(np.arange(0						,      image.shape[1]		)						,      np.arange(0						,      image.shape[0]		)		)						,      2		)
						UpperCAmelCase			 =					np.round(grid - flow		).astype(np.intaa		)

						# Find the locations outside of the original image
						UpperCAmelCase			 =					(grid < 0) | (grid >= np.array([image.shape[1], image.shape[0]]		))
						UpperCAmelCase			 =					0

						UpperCAmelCase			 =					image[grid[:, :, 1], grid[:, :, 0]]

						# Set pixels at invalid locations to 0
						UpperCAmelCase			 =					0

						return warped

def 					_lowerCAmelCase (  lowercase_						,      lowercase_						,      lowercase_						,      lowercase_ = None						,      ):
						if alpha is None:
												UpperCAmelCase			 =					0.1

						# Initialize flow
						UpperCAmelCase			 =					np.zeros_like(lowercase_		)
						UpperCAmelCase			 =					np.zeros_like(lowercase_		)

						# Prepare kernels for the calculation of the derivatives and the average velocity
						UpperCAmelCase			 =					np.array([[-1, 1], [-1, 1]]		) * 0.2_5
						UpperCAmelCase			 =					np.array([[-1, -1], [1, 1]]		) * 0.2_5
						UpperCAmelCase			 =					np.array([[1, 1], [1, 1]]		) * 0.2_5
						UpperCAmelCase			 =					np.array(
						    [[1 / 12, 1 / 6, 1 / 12], [1 / 6, 0, 1 / 6], [1 / 12, 1 / 6, 1 / 12]]		)

						# Iteratively refine the flow
						for _ in range(lowercase_		):
												UpperCAmelCase			 =					warp(lowercase_						,      lowercase_						,      lowercase_		)
												UpperCAmelCase			 =					convolve(lowercase_						,      lowercase_		) + convolve(lowercase_						,      lowercase_		)
												UpperCAmelCase			 =					convolve(lowercase_						,      lowercase_		) + convolve(lowercase_						,      lowercase_		)
												UpperCAmelCase			 =					convolve(lowercase_						,      lowercase_		) + convolve(lowercase_						,      -kernel_t		)

												UpperCAmelCase			 =					convolve(lowercase_						,      lowercase_		)
												UpperCAmelCase			 =					convolve(lowercase_						,      lowercase_		)

												# This updates the flow as proposed in the paper (Step 12)
												UpperCAmelCase			 =					(
												    derivative_x * avg_horizontal_velocity
												    + derivative_y * avg_vertical_velocity
												    + derivative_t
												)
												UpperCAmelCase			 =					update / (alpha**2 + derivative_x**2 + derivative_y**2)

												UpperCAmelCase			 =					avg_horizontal_velocity - derivative_x * update
												UpperCAmelCase			 =					avg_vertical_velocity - derivative_y * update

						return horizontal_flow, vertical_flow


if __name__ == "__main__":
				import doctest

				doctest.testmod()










'''simple docstring'''






def        snake_case_   (	lowerCAmelCase_			,  lowerCAmelCase_						)->						float:





       '''simple docstring'''


       return a + b


if __name__ == "__main__":
   A_				:					Tuple							=      5
   A_				:					Tuple							=      6
   print(f"""The sum of {a} + {b} is {add(a, b)}""")



