


from manim import *







class   lowerCAmelCase__ (       a):




     '''simple docstring'''


     def 				_lowerCamelCase				(		self)    ->       Tuple:
            _A   : Tuple       					=				Rectangle(height=0.5				,		width=0.5)
            _A   : Dict       					=				Rectangle(height=0.4_6				,		width=0.4_6).set_stroke(width=0)
            _A   : str       					=				Rectangle(height=0.2_5				,		width=0.2_5)

            _A   : Union[str, Any]       					=				[mem.copy() for i in range(6)]
            _A   : int       					=				[mem.copy() for i in range(6)]
            _A   : List[str]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Union[str, Any]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Union[str, Any]       					=				VGroup(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : List[Any]       					=				Text("CPU"				,		font_size=2_4)
            _A   : List[str]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
            cpu.move_to([-2.5, -0.5, 0])
            self.add(__lowerCamelCase)

            _A   : Optional[int]       					=				[mem.copy() for i in range(4)]
            _A   : Dict       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Optional[int]       					=				Text("GPU"				,		font_size=2_4)
            _A   : Optional[Any]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
            gpu.move_to([-1, -1, 0])
            self.add(__lowerCamelCase)

            _A   : int       					=				[mem.copy() for i in range(6)]
            _A   : Any       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)

            _A   : int       					=				Text("Model"				,		font_size=2_4)
            _A   : str       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
            model.move_to([3, -1.0, 0])
            self.add(__lowerCamelCase)

            _A   : Tuple       					=				[]
            _A   : Any       					=				[]

            for i, rect in enumerate(__lowerCamelCase):
                   rect.set_stroke(__lowerCamelCase)

                   _A   : Any       					=				Rectangle(height=0.4_6 / 4				,		width=0.4_6 / 3).set_stroke(width=0.0).set_fill(__lowerCamelCase				,		opacity=0.7)

                   if i == 0:
                          cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)				,		buff=0.0_2				,		direction=__lowerCamelCase)
                          cpu_target.set_x(cpu_target.get_x() + 0.1)
                   elif i == 3:
                          cpu_target.next_to(model_cpu_arr[0]				,		direction=__lowerCamelCase				,		buff=0.0)
                   else:
                          cpu_target.next_to(model_cpu_arr[i - 1]				,		direction=__lowerCamelCase				,		buff=0.0)
                   self.add(__lowerCamelCase)
                   model_cpu_arr.append(__lowerCamelCase)

            self.add(*__lowerCamelCase				,		*__lowerCamelCase)

            _A   : List[Any]       					=				[meta_mem.copy() for i in range(6)]
            _A   : int       					=				[meta_mem.copy() for i in range(6)]
            _A   : int       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Optional[int]       					=				VGroup(*__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Optional[int]       					=				VGroup(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0)
            _A   : Dict       					=				Text("Disk"				,		font_size=2_4)
            _A   : Optional[Any]       					=				Group(__lowerCamelCase				,		__lowerCamelCase).arrange(__lowerCamelCase				,		buff=0.5				,		aligned_edge=__lowerCamelCase)
            disk.move_to([-4.0, -1.2_5, 0])
            self.add(__lowerCamelCase				,		__lowerCamelCase)

            _A   : Union[str, Any]       					=				[]

            for i in range(6):
                   _A   : Optional[int]       					=				fill.copy().set_fill(__lowerCamelCase				,		opacity=0.8)
                   target.move_to(disk_left_col_base[i]).scale(0.5)
                   cpu_disk_arr.append(__lowerCamelCase)

            self.add(*__lowerCamelCase)

            _A   : Dict       					=				Square(side_length=2.2)
            key.move_to([-5, 2, 0])

            _A   : Optional[int]       					=				MarkupText(
                F"<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"				,		font_size=1_8				,		)

            key_text.move_to([-5, 2.4, 0])

            self.add(__lowerCamelCase				,		__lowerCamelCase)

            _A   : Tuple       					=				MarkupText(
                F"<span fgcolor='{BLUE}'>●</span> Checkpoint"				,		font_size=1_8				,		)

            blue_text.next_to(__lowerCamelCase				,		DOWN * 2.4				,		aligned_edge=key_text.get_left())
            self.add(__lowerCamelCase)

            _A   : int       					=				MarkupText(F"The offloaded weights are all sent to the CPU."				,		font_size=2_4)
            step_a.move_to([2, 2, 0])

            self.play(Write(__lowerCamelCase				,		run_time=3))

            for i in range(6):
                   _A   : str       					=				cpu_disk_arr[i]
                   _A   : Dict       					=				rect.copy().set_fill(__lowerCamelCase				,		opacity=0.8).scale(2.0)
                   cpa.generate_target()
                   cpa.target.move_to(model_base[i])

                   if i == 0:
                          rect.set_fill(__lowerCamelCase				,		opacity=0.8)
                          rect.generate_target()
                          rect.target.move_to(cpu_left_col_base[0]).scale(2.0)

                          self.remove(
                              *__lowerCamelCase				,		*__lowerCamelCase				,		)

                   else:
                          rect.generate_target()
                          rect.target.move_to(cpu_left_col_base[i]).scale(2.0)
                   self.play(MoveToTarget(__lowerCamelCase)				,		MoveToTarget(__lowerCamelCase)				,		model_base[i].animate.set_stroke(__lowerCamelCase))
            self.play(FadeOut(__lowerCamelCase))

            _A   : Any       					=				MarkupText(
                F"Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed."				,		font_size=2_4				,		)
            step_a.move_to([2, 2, 0])

            self.play(Write(__lowerCamelCase				,		run_time=3))

            _A   : Any       					=				[]
            _A   : str       					=				[]
            for i in range(6):
                   _A   : Optional[Any]       					=				Arrow(start=__lowerCamelCase				,		end=__lowerCamelCase				,		color=__lowerCamelCase				,		buff=0.5)
                   a.next_to(model_base[i].get_left()				,		__lowerCamelCase				,		buff=0.2)
                   arrows.append(__lowerCamelCase)
                   animations.append(Write(__lowerCamelCase))
            self.play(*__lowerCamelCase)
            self.wait()




import cva
import numpy as np

from digital_image_processing.filters.convolve import img_convolve
from digital_image_processing.filters.sobel_filter import sobel_filter

lowerCAmelCase__   	=				1_80
def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[Any]		):
       _A   : int       					=				k_size // 2
       _A					,    _A   : Tuple       					=				np.mgrid[0 - center : k_size - center, 0 - center : k_size - center]
       _A   : Union[str, Any]       					=				(
           1
           / (2 * np.pi * sigma)
           * np.exp(-(np.square(UpperCamelCase__		) + np.square(UpperCamelCase__		)) / (2 * np.square(UpperCamelCase__		))		)
       )
       return g
def 							_UpperCAmelCase       (UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Tuple		):
       _A   : Optional[int]       					=				np.zeros(UpperCamelCase__		)

       for row in range(1       ,							image_shape[0] - 1		):
              for col in range(1       ,							image_shape[1] - 1		):
                     _A   : Dict       					=				gradient_direction[row, col]

                     if (
                         0 <= direction < PI / 8
                         or 15 * PI / 8 <= direction <= 2 * PI
                         or 7 * PI / 8 <= direction <= 9 * PI / 8
                     ):
                            _A   : Dict       					=				sobel_grad[row, col - 1]
                            _A   : Any       					=				sobel_grad[row, col + 1]
                            if sobel_grad[row, col] >= w and sobel_grad[row, col] >= e:
                                   _A   : List[Any]       					=				sobel_grad[row, col]

                     elif (
                         PI / 8 <= direction < 3 * PI / 8
                         or 9 * PI / 8 <= direction < 11 * PI / 8
                     ):
                            _A   : List[str]       					=				sobel_grad[row + 1, col - 1]
                            _A   : str       					=				sobel_grad[row - 1, col + 1]
                            if sobel_grad[row, col] >= sw and sobel_grad[row, col] >= ne:
                                   _A   : List[Any]       					=				sobel_grad[row, col]

                     elif (
                         3 * PI / 8 <= direction < 5 * PI / 8
                         or 11 * PI / 8 <= direction < 13 * PI / 8
                     ):
                            _A   : Any       					=				sobel_grad[row - 1, col]
                            _A   : int       					=				sobel_grad[row + 1, col]
                            if sobel_grad[row, col] >= n and sobel_grad[row, col] >= s:
                                   _A   : Any       					=				sobel_grad[row, col]

                     elif (
                         5 * PI / 8 <= direction < 7 * PI / 8
                         or 13 * PI / 8 <= direction < 15 * PI / 8
                     ):
                            _A   : List[str]       					=				sobel_grad[row - 1, col - 1]
                            _A   : Optional[Any]       					=				sobel_grad[row + 1, col + 1]
                            if sobel_grad[row, col] >= nw and sobel_grad[row, col] >= se:
                                   _A   : List[Any]       					=				sobel_grad[row, col]

       return destination
def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Any		):
       for row in range(1       ,							image_shape[0] - 1		):
              for col in range(1       ,							image_shape[1] - 1		):
                     if destination[row, col] >= threshold_high:
                            _A   : Optional[int]       					=				strong
                     elif destination[row, col] <= threshold_low:
                            _A   : Optional[int]       					=				0
                     else:
                            _A   : Union[str, Any]       					=				weak
def 							_UpperCAmelCase       (UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[int]       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Any		):
       for row in range(1       ,							image_shape[0]		):
              for col in range(1       ,							image_shape[1]		):
                     if destination[row, col] == weak:
                            if 255 in (
                                destination[row, col + 1],
                                destination[row, col - 1],
                                destination[row - 1, col],
                                destination[row + 1, col],
                                destination[row - 1, col - 1],
                                destination[row + 1, col - 1],
                                destination[row - 1, col + 1],
                                destination[row + 1, col + 1],
                            ):
                                   _A   : str       					=				strong
                            else:
                                   _A   : Any       					=				0
def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						int=15       ,							UpperCamelCase__  :						Dict=30       ,							UpperCamelCase__  :						int=128       ,							UpperCamelCase__  :						Union[str, Any]=255		):
       # gaussian_filter
       _A   : Union[str, Any]       					=				img_convolve(UpperCamelCase__       ,							gen_gaussian_kernel(9       ,							sigma=1.4		)		)
       # get the gradient and degree by sobel_filter
       _A					,    _A   : Dict       					=				sobel_filter(UpperCamelCase__		)
       _A   : Tuple       					=				PI + np.radadeg(UpperCamelCase__		)

       _A   : Optional[int]       					=				suppress_non_maximum(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__		)

       detect_high_low_threshold(
           image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)

       track_edge(image.shape       ,							UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__		)

       return destination


if __name__ == "__main__":
    # read original image in gray mode
    lowerCAmelCase__   	=				cva.imread(R'../image_data/lena.jpg', 0)
    # canny edge detection
    lowerCAmelCase__   	=				canny(lena)
    cva.imshow('canny', canny_destination)
    cva.waitKey(0)
