






def        _lowerCamelCase		(  __A      :							Tuple						,						__A      :							str	) ->   Dict:
    print('''\nVertex Distance'''	)
    for i in range(__A	):
        if dist[i] != float('''inf'''	):
            print(__A						,						'''\t'''						,						int(dist[i]	)						,						end='''\t'''	)
        else:
            print(__A						,						'''\t'''						,						'''INF'''						,						end='''\t'''	)
        print()

def        _lowerCamelCase		(  __A      :							List[str]						,						__A      :							Optional[Any]						,						__A      :							str	) ->   Optional[int]:
    _UpperCAmelCase			: str     					=			float('''inf'''	)
    _UpperCAmelCase			: str     					=			-1
    for i in range(__A	):
        if (not vset[i]) and mdist[i] < min_val:
            _UpperCAmelCase			: Dict     					=			i
            _UpperCAmelCase			: str     					=			mdist[i]
    return min_ind

def        _lowerCamelCase		(  __A      :							Any						,						__A      :							List[Any]						,						__A      :							str	) ->   Union[str, Any]:
    _UpperCAmelCase			: Optional[Any]     					=			[float('''inf'''	) for _ in range(__A	)]
    _UpperCAmelCase			: Union[str, Any]     					=			[False for _ in range(__A	)]
    _UpperCAmelCase			: Any     					=			0.0

    for _ in range(v - 1	):
        _UpperCAmelCase			: Optional[Any]     					=			min_dist(__A						,						__A						,						__A	)
        _UpperCAmelCase			: List[Any]     					=			True

        for i in range(__A	):
            if (
                (not vset[i])
                and graph[u][i] != float('''inf'''	)
                and mdist[u] + graph[u][i] < mdist[i]
            ):
                _UpperCAmelCase			: Tuple     					=			mdist[u] + graph[u][i]

    print_dist(__A						,						__A	)


if __name__ == "__main__":
  SCREAMING_SNAKE_CASE								=  int(input('Enter number of vertices: ').strip())
  SCREAMING_SNAKE_CASE								=  int(input('Enter number of edges: ').strip())

  SCREAMING_SNAKE_CASE								=  [[float('inf') for i in range(V)] for j in range(V)]

  for i in range(V):
    SCREAMING_SNAKE_CASE								=  0.0

  for i in range(E):
    print('\nEdge ', i + 1)
    SCREAMING_SNAKE_CASE								=  int(input('Enter source:').strip())
    SCREAMING_SNAKE_CASE								=  int(input('Enter destination:').strip())
    SCREAMING_SNAKE_CASE								=  float(input('Enter weight:').strip())
    SCREAMING_SNAKE_CASE								=  weight

  SCREAMING_SNAKE_CASE								=  int(input('\nEnter shortest path source:').strip())
  dijkstra(graph, V, gsrc)












from cva import COLOR_BGR2GRAY, cvtColor, imread, imshow, waitKey
from numpy import divide, inta, multiply, ravel, sort, zeros_like

def        _lowerCamelCase		(  __A      :							str						,						__A      :							List[str]=3	) ->   List[Any]:
    _UpperCAmelCase			: Tuple     					=			int(mask / 2	)
    # copy image size
    _UpperCAmelCase			: Any     					=			zeros_like(__A	)
    for i in range(__A						,						gray_img.shape[0] - bd	):
        for j in range(__A						,						gray_img.shape[1] - bd	):
            # get mask according with mask
            _UpperCAmelCase			: Any     					=			ravel(gray_img[i - bd : i + bd + 1, j - bd : j + bd + 1]	)
            # calculate mask median
            _UpperCAmelCase			: List[str]     					=			sort(__A	)[inta(divide((multiply(__A						,						__A	))						,						2	) + 1	)]
            _UpperCAmelCase			: int     					=			median
    return median_img


if __name__ == "__main__":
  # read original image
  SCREAMING_SNAKE_CASE								=  imread('../image_data/lena.jpg')
  # turn image in gray scale value
  SCREAMING_SNAKE_CASE								=  cvtColor(img, COLOR_BGR2GRAY)

  # get values with two different mask size
  SCREAMING_SNAKE_CASE								=  median_filter(gray, 3)
  SCREAMING_SNAKE_CASE								=  median_filter(gray, 5)

  # show result images
  imshow('median filter with 3x3 mask', medianaxa)
  imshow('median filter with 5x5 mask', medianaxa)
  waitKey(0)




