

'''simple docstring'''





A_	= {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

A_	= {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}







def   _UpperCamelCase	(		__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)       ->			list[int]:
					lowerCamelCase_  				=      True
					lowerCamelCase_  				=      []

					for neighbour in graph[vert]:
										if not visited[neighbour]:
															order += topology_sort(__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)

					order.append(__UpperCamelCase	)

					return order







def   _UpperCamelCase	(		__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)       ->			list[int]:
					lowerCamelCase_  				=      True
					lowerCamelCase_  				=      [vert]

					for neighbour in reversed_graph[vert]:
										if not visited[neighbour]:
															component += find_components(__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)

					return component







def   _UpperCamelCase	(		__UpperCamelCase	)       ->			list[list[int]]:
					lowerCamelCase_  				=      len(__UpperCamelCase	) * [False]
					lowerCamelCase_  				=      {vert: [] for vert in range(len(__UpperCamelCase	)	)}

					for vert, neighbours in graph.items():
										for neighbour in neighbours:
															reversed_graph[neighbour].append(__UpperCamelCase	)

					lowerCamelCase_  				=      []
					for i, was_visited in enumerate(__UpperCamelCase	):
										if not was_visited:
															order += topology_sort(__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)

					lowerCamelCase_  				=      []
					lowerCamelCase_  				=      len(__UpperCamelCase	) * [False]

					for i in range(len(__UpperCamelCase	)	):
										lowerCamelCase_  				=      order[len(__UpperCamelCase	) - i - 1]
										if not visited[vert]:
															lowerCamelCase_  				=      find_components(__UpperCamelCase    ,__UpperCamelCase    ,__UpperCamelCase	)
															components_list.append(__UpperCamelCase	)

					return components_list










import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey


class       __lowerCAmelCase					:


	'''simple docstring'''





	def __init__(						self:						List[str],					lowerCamelCase_:						Optional[Any],					lowerCamelCase_:						int,					lowerCamelCase_:						int			):
			if dst_width < 0 or dst_height < 0:
					raise ValueError('Destination width/height should be > 0'			)

			lowercase__					:      str      =		img
			lowercase__					:      Tuple      =		img.shape[1]
			lowercase__					:      str      =		img.shape[0]
			lowercase__					:      Tuple      =		dst_width
			lowercase__					:      Any      =		dst_height

			lowercase__					:      Tuple      =		self.src_w / self.dst_w
			lowercase__					:      Union[str, Any]      =		self.src_h / self.dst_h

			lowercase__					:      List[Any]      =		(
			    np.ones((self.dst_h, self.dst_w, 3),					np.uinta			) * 255
			)

	def    snake_case__(						self:						Dict			):
			for i in range(self.dst_h			):
					for j in range(self.dst_w			):
							lowercase__					:      Tuple      =		self.img[self.get_y(lowerCamelCase_			)][self.get_x(lowerCamelCase_			)]

	def    snake_case__(						self:						List[str],					lowerCamelCase_:						int			):
			return int(self.ratio_x * x			)





	def    snake_case__(						self:						int,					lowerCamelCase_:						int			):
			return int(self.ratio_y * y			)


if __name__ == "__main__":
			__UpperCamelCase,	__UpperCamelCase:	List[Any] = 8_0_0, 6_0_0
			__UpperCamelCase:	Optional[Any] = imread("""image_data/lena.jpg""", 1)
			__UpperCamelCase:	Union[str, Any] = NearestNeighbour(im, dst_w, dst_h)
			n.process()

			imshow(
			    F'Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}', n.output
			)
			waitKey(0)
			destroyAllWindows()


