
    -i'                     H    d Z ddlZ	 	 	 	 	 	 	 d
dZ	 	 	 	 	 	 	 	 ddZdd	ZdS )zDeals with making images (np arrays). It provides drawing
methods that are difficult to do with the existing Python libraries.
    N              ?linearc	                      \  }	}
t          j        |                              t                    }t          j        |                              t                    }|dk    r|:|t	          d          t          j        |          t          j                  z
  } fd|d |D             fD             \  }}t          j        ||          }|j        dk    rt          j        d|gz            }||z  d|z
  |z  z   S t          j        ddd                                       t                    t          j        t          j        t          |	          t          |
                    ddd                                       t                    }|d	k    r|2|!t          j        |ddd                   z
  }n,t	          d          t          j        |ddd                   }t           j
                            |          }||d
z  z  }|z  z   |z
                      |          dz
  z  }t          j        dt          j        d|                    }|j        dk    rt          j        d|gz            }||z  d|z
  |z  z   S |dk    r|pddk    rt          j        |
|	f          }ngt          j        |z
  d
z                      d
                    |z  z
  }|dz
  |z  z  }t          j        dt          j        d|                    }|j        dk    rt          j        d|gz            }d|z
  |z  ||z  z   S t	          d          )aq  Draw a linear, bilinear, or radial gradient.

    The result is a picture of size ``size``, whose color varies
    gradually from color `color_1` in position ``p1`` to color ``color_2``
    in position ``p2``.

    If it is a RGB picture the result must be transformed into
    a 'uint8' array to be displayed normally:

    Parameters
    ----------

    size : tuple or list
        Size (width, height) in pixels of the final image array.

    p1 : tuple or list
       Position for the first coordinate of the gradient in pixels (x, y).
       The color 'before' ``p1`` is ``color_1`` and it gradually changes in
       the direction of ``p2`` until it is ``color_2`` when it reaches ``p2``.

    p2 : tuple or list, optional
       Position for the second coordinate of the gradient in pixels (x, y).
        Coordinates (x, y)  of the limit point for ``color_1``
        and ``color_2``.

    vector : tuple or list, optional
        A vector (x, y) in pixels that can be provided instead of ``p2``.
        ``p2`` is then defined as (p1 + vector).

    color_1 : tuple or list, optional
        Starting color for the gradient. As default, black. Either floats
        between 0 and 1 (for gradients used in masks) or [R, G, B] arrays
        (for colored gradients).

    color_2 : tuple or list, optional
        Color for the second point in the gradient. As default, white. Either
        floats between 0 and 1 (for gradients used in masks) or [R, G, B]
        arrays (for colored gradients).

    shape : str, optional
        Shape of the gradient. Can be either ``"linear"``, ``"bilinear"`` or
        ``"circular"``. In a linear gradient the color varies in one direction,
        from point ``p1`` to point ``p2``. In a bilinear gradient it also
        varies symmetrically from ``p1`` in the other direction. In a circular
        gradient it goes from ``color_1`` to ``color_2`` in all directions.

    radius : float, optional
        If ``shape="radial"``, the radius of the gradient is defined with the
        parameter ``radius``, in pixels.

    offset : float, optional
        Real number between 0 and 1 indicating the fraction of the vector
        at which the gradient actually starts. For instance if ``offset``
        is 0.9 in a gradient going from p1 to p2, then the gradient will
        only occur near p2 (before that everything is of color ``color_1``)
        If the offset is 0.9 in a radial gradient, the gradient will
        occur in the region located between 90% and 100% of the radius,
        this creates a blurry disc of radius ``d(p1, p2)``.

    Returns
    -------

    image
        An Numpy array of dimensions (width, height, n_colors) of type float
        representing the image of the gradient.

    Examples
    --------

    .. code:: python

        color_gradient((10, 1), (0, 0), p2=(10, 0))  # from white to black
        #[[1.  0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1]]
        # from red to green
        color_gradient(
            (10, 1), (0, 0),
            p2=(10, 0),
            color_1=(255, 0, 0),
            color_2=(0, 255, 0)
        )
        # [[[  0.  255.    0. ]
        #   [ 25.5 229.5   0. ]
        #   [ 51.  204.    0. ]
        #   [ 76.5 178.5   0. ]
        #   [102.  153.    0. ]
        #   [127.5 127.5   0. ]
        #   [153.  102.    0. ]
        #   [178.5  76.5   0. ]
        #   [204.   51.    0. ]
        #   [229.5  25.5   0. ]]]
    bilinearNz(You must provide either 'p2' or 'vector'c                 <    g | ]}t          |d dd          S )r   r   r   )vectorcolor_1color_2shapeoffsetcolor_gradient).0vr   p1sizes     Y/var/www/html/speakWrite/venv/lib/python3.11/site-packages/moviepy/video/tools/drawing.py
<listcomp>z"color_gradient.<locals>.<listcomp>z   sO     
 
 
    
 
 
    c                     g | ]}| S  r   )r   r   s     r   r   z"color_gradient.<locals>.<listcomp>   s    222ar222r         r      r   radial)axisr   z@Invalid shape, should be either 'radial', 'linear' or 'bilinear')nparrayastypefloat
ValueErrormaximumr   dstackmeshgridrangelinalgnormdotminimumonessqrtsum)r   r   p2r	   radiusr
   r   r   r   whm1m2arrMr)   n_vecs   ``      `        r   r   r      sa   N DAqhw&&u--Ghw&&u--G
>z !KLLLXb\\BHRLL0F
 
 
 
 
 
 2262223
 
 
B jR  <!)AI&&CW}C7222	"TTrT(			"	"5	)	)B
	"+eAhha11$$B$788??FFA>~"TTrT(++b0 !KLLLXfTTrTl++Fy~~f%%q &6/!2vll5!!QZ0jBJq#..//<!)AI&&CW}C7222	(		KaA'1a&//CC7QVM..A.66776F?JC!f*./C*S"*Q"4"455C<!)AI&&CC7"S7]22
W
X
XXr   c	                    |s|||*t          j        |          t          j        |          z
  }n]|-t          j        ddg          }t          j        |dg          }n.|,t          j        ddg          }t          j        d|g          }|\  }}t          j        || g                              d          }t           j                            |          }	t          d|          |z  |	z  }t          | ||||d	          S | \  }
}t          j        |          r||
fn||
t          |          f}t          j	        |          }|r||ddd|f<   ||dd|df<   n|r||d|<   |||d<   |S )
a  Make an image split in 2 colored regions.

    Returns an array of size ``size`` divided in two regions called 1 and
    2 in what follows, and which will have colors color_1 and color_2
    respectively.

    Parameters
    ----------

    x : int, optional
        If provided, the image is split horizontally in x, the left
        region being region 1.

    y : int, optional
        If provided, the image is split vertically in y, the top region
        being region 1.

    p1, p2: tuple or list, optional
        Positions (x1, y1), (x2, y2) in pixels, where the numbers can be
        floats. Region 1 is defined as the whole region on the left when
        going from ``p1`` to ``p2``.

    p1, vector: tuple or list, optional
        ``p1`` is (x1,y1) and vector (v1,v2), where the numbers can be
        floats. Region 1 is then the region on the left when starting
        in position ``p1`` and going in the direction given by ``vector``.

    gradient_width : float, optional
        If not zero, the split is not sharp, but gradual over a region of
        width ``gradient_width`` (in pixels). This is preferable in many
        situations (for instance for antialiasing).

    Examples
    --------

    .. code:: python

        size = [200, 200]

        # an image with all pixels with x<50 =0, the others =1
        color_split(size, x=50, color_1=0, color_2=1)

        # an image with all pixels with y<50 red, the others green
        color_split(size, x=50, color_1=[255, 0, 0], color_2=[0, 255, 0])

        # An image split along an arbitrary line (see below)
        color_split(size, p1=[20, 50], p2=[25, 70], color_1=0, color_2=1)
    Nr   g      r   r   r"   g?r   )r	   r
   r   r   )
r   r    r!   r(   r)   maxr   isscalarlenzeros)r   xyr   r/   r	   r
   r   gradient_widthr)   r1   r2   r   r5   s                 r   color_splitr@      s   v  1919>Xb\\BHRLL0FF]Xq$i((F1a&!!BB]XsCj))F1a&!!B11qb'""))'22y~~f%%S.))F2T9"VWgX
 
 
 	
 1+g..HAQ3w<<4Hhuoo 	 C2A2J C122JJ 	CGCG
r   r   c           	      L    |rd||z
  z  |z  nd}t          | ||||d|          S )a  Draw an image with a circle.

    Draws a circle of color ``color``, on a background of color ``bg_color``,
    on a screen of size ``screensize`` at the position ``center=(x, y)``,
    with a radius ``radius`` but slightly blurred on the border by ``blur``
    pixels.

    Parameters
    ----------

    screensize : tuple or list
        Size of the canvas.

    center : tuple or list
        Center of the circle.

    radius : float
        Radius of the circle, in pixels.

    bg_color : tuple or float, optional
        Color for the background of the canvas. As default, black.

    blur : float, optional
        Blur for the border of the circle.

    Examples
    --------

    .. code:: python

        from moviepy.video.tools.drawing import circle

        circle(
            (5, 5),  # size
            (2, 2),  # center
            2,      # radius
        )
        # array([[0.        , 0.        , 0.        , 0.        , 0.        ],
        #        [0.        , 0.58578644, 1.        , 0.58578644, 0.        ],
        #        [0.        , 1.        , 1.        , 1.        , 0.        ],
        #        [0.        , 0.58578644, 1.        , 0.58578644, 0.        ],
        #        [0.        , 0.        , 0.        , 0.        , 0.        ]])
    r   r   r   )r   r0   r
   r   r   r   r   )
screensizecenterr0   colorbg_colorblurr   s          r   circlerG   
  sN    X 06<SFTM"V++1F   r   )NNNr   r   r   r   )NNNNNr   r   r   )r   r   r   )__doc__numpyr   r   r@   rG   r   r   r   <module>rJ      s         
fY fY fY fYV 
V V V Vr5 5 5 5 5 5r   