

from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve





def  _snake_case		(snake_case_					:     np.ndarray    ,       snake_case_					:     np.ndarray    ,       snake_case_					:     np.ndarray  )							->		np.ndarray:
  __UpperCAmelCase	:  Dict		=     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	:  Union[str, Any]		=     np.stack(
      np.meshgrid(np.arange(0    ,       image.shape[1]  )    ,       np.arange(0    ,       image.shape[0]  )  )    ,       2  )
  __UpperCAmelCase	:  Any		=     np.round(grid - flow  ).astype(np.intaa  )

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

  __UpperCAmelCase	:  Union[str, Any]		=     image[grid[:, :, 1], grid[:, :, 0]]

  # Set pixels at invalid locations to 0
  __UpperCAmelCase	:  Tuple		=     0

  return warped





def  _snake_case		(snake_case_					:     np.ndarray    ,       snake_case_					:     np.ndarray    ,       snake_case_					:     SupportsIndex    ,       snake_case_					:     float | None = None    ,       )							->		tuple[np.ndarray, np.ndarray]:
  if alpha is None:
    __UpperCAmelCase	:  str		=     0.1

  # Initialize flow
  __UpperCAmelCase	:  Optional[int]		=     np.zeros_like(snake_case_  )
  __UpperCAmelCase	:  Dict		=     np.zeros_like(snake_case_  )

  # Prepare kernels for the calculation of the derivatives and the average velocity
  __UpperCAmelCase	:  Any		=     np.array([[-1, 1], [-1, 1]]  ) * 0.25
  __UpperCAmelCase	:  Dict		=     np.array([[-1, -1], [1, 1]]  ) * 0.25
  __UpperCAmelCase	:  Optional[int]		=     np.array([[1, 1], [1, 1]]  ) * 0.25
  __UpperCAmelCase	:  Optional[int]		=     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(snake_case_  ):
    __UpperCAmelCase	:  Any		=     warp(snake_case_    ,       snake_case_    ,       snake_case_  )
    __UpperCAmelCase	:  List[str]		=     convolve(snake_case_    ,       snake_case_  ) + convolve(snake_case_    ,       snake_case_  )
    __UpperCAmelCase	:  Union[str, Any]		=     convolve(snake_case_    ,       snake_case_  ) + convolve(snake_case_    ,       snake_case_  )
    __UpperCAmelCase	:  List[Any]		=     convolve(snake_case_    ,       snake_case_  ) + convolve(snake_case_    ,       -kernel_t  )

    __UpperCAmelCase	:  str		=     convolve(snake_case_    ,       snake_case_  )
    __UpperCAmelCase	:  Dict		=     convolve(snake_case_    ,       snake_case_  )

    # This updates the flow as proposed in the paper (Step 12)
    __UpperCAmelCase	:  List[str]		=     (
        derivative_x * avg_horizontal_velocity
        + derivative_y * avg_vertical_velocity
        + derivative_t
    )
    __UpperCAmelCase	:  List[Any]		=     update / (alpha**2 + derivative_x**2 + derivative_y**2)

    __UpperCAmelCase	:  Dict		=     avg_horizontal_velocity - derivative_x * update
    __UpperCAmelCase	:  Optional[int]		=     avg_vertical_velocity - derivative_y * update

  return horizontal_flow, vertical_flow


if __name__ == "__main__":
      import doctest

      doctest.testmod()








"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A									=						{
    """configuration_imagegpt""": ["""IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ImageGPTConfig""", """ImageGPTOnnxConfig"""]
}

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A									=						["""ImageGPTFeatureExtractor"""]
 A									=						["""ImageGPTImageProcessor"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A									=						[
     """IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """ImageGPTForCausalImageModeling""",
     """ImageGPTForImageClassification""",
     """ImageGPTModel""",
     """ImageGPTPreTrainedModel""",
     """load_tf_weights_in_imagegpt""",
 ]


if TYPE_CHECKING:
 from .configuration_imagegpt import IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ImageGPTConfig, ImageGPTOnnxConfig

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_imagegpt import ImageGPTFeatureExtractor
  from .image_processing_imagegpt import ImageGPTImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_imagegpt import (
      IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      ImageGPTForCausalImageModeling,
      ImageGPTForImageClassification,
      ImageGPTModel,
      ImageGPTPreTrainedModel,
      load_tf_weights_in_imagegpt,
  )

else:
 import sys

 A									=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
