
'''simple docstring'''
def 						A_(			A		:						str):
							return "".join(chr(ord(A) + 32) if 'A' <= char <= 'Z' else char for char in word)


if __name__ == "__main__":
						from doctest import testmod

						testmod()






'''simple docstring'''
from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve







def 						A_(			A		:						np.ndarray						,			A		:						np.ndarray						,			A		:						np.ndarray):
							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 						A_(			A		:						np.ndarray						,			A		:						np.ndarray						,			A		:						SupportsIndex						,			A		:						float | None = None						,			):
							if alpha is None:
														UpperCamelCase					       =			0.1

							# Initialize flow
							UpperCamelCase					       =			np.zeros_like(A)
							UpperCamelCase					       =			np.zeros_like(A)

							# Prepare kernels for the calculation of the derivatives and the average velocity
							UpperCamelCase					       =			np.array([[-1, 1], [-1, 1]]) * 0.25
							UpperCamelCase					       =			np.array([[-1, -1], [1, 1]]) * 0.25
							UpperCamelCase					       =			np.array([[1, 1], [1, 1]]) * 0.25
							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(A):
														UpperCamelCase					       =			warp(A						,			A						,			A)
														UpperCamelCase					       =			convolve(A						,			A) + convolve(A						,			A)
														UpperCamelCase					       =			convolve(A						,			A) + convolve(A						,			A)
														UpperCamelCase					       =			convolve(A						,			A) + convolve(A						,			-kernel_t)

														UpperCamelCase					       =			convolve(A						,			A)
														UpperCamelCase					       =			convolve(A						,			A)

														# 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()




