`i|<ddlZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z ddl mZejjjZd Zd Zd d ejd fdZd ejd fdZd dZdZdZ d!dZ d"dddZdZ d#dZ d!dZ d!dddZdS)$N)_core)internal)runtime)_texture)_util)_interp_kernels)_spline_prefilter_corec|tjd|dn|dksd|krtd|dvr"td|dS)NzCurrently the default order of zG is 1. In a future release this may change to 3 to match scipy.ndimage rzspline order is not supported) constant grid-constantnearestmirrorreflectz grid-mirrorwrap grid-wrapopencv _opencv_edgez#boundary mode ({}) is not supported)warningswarn ValueErrorformat) func_nameordermodes v/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/ndimage/_interpolation.py_check_parameterrs } ' ''' ( ( ( ( a%ii8999 $$$>EEdKKLLL$$c|jjdk}|r tj}n tj}t |tjrC|r|jjdkrtdtj|j|}|j}n5| |jx}}ntj|}tj||}t |tjr=|j|cxkr|kr+nn(|j j r||urtj |||}nU| |d}tj|}tj||dr|}|||fS)zCreate workspace array, temp, and the final dtype for the output. Differs from SciPy by not always forcing the internal floating point dtype to be double precision. cz1output must have complex dtype for complex inputsNFcopyMAY_SHARE_BOUNDS)dtypekindcupy complex64float32 isinstancendarrayr promote_typesflags c_contiguousrelementwise_copyastypeascontiguousarray shares_memoryr")inputoutput complex_datamin_float_dtype float_dtype output_dtypetemps r_get_spline_outputr9 s ;#s*L'.,&$,'' B  FL-44C (GG | >$)K /F\\:f--L(AA 64<((  ;;;;|;;;;; )<     "5& 1 1 1||Ke|44%d++  dE+= > > 99;;D l **rrc |dks|dkrtd|}|j}tj||}|dkp|jdkp|j|dk }|s,t j||}tj|||St||\}} } tjj |j } tjj |jj } t j|} | dkr tjn tj}|j|}|j|z}tj||f|jz|}t)dt+jt/j|dz zd }t3j||||| | | | }|f}||dzdz |dzf}t3j| }|t3j|z}|||||ft;|tjr||urtj|||S|| d S)a$ Calculate a 1-D spline filter along the given axis. The lines of the array along the given axis are filtered by a spline filter. The order of the spline must be >= 2 and <= 5. Args: input (cupy.ndarray): The input array. order (int): The order of the spline interpolation, default is 3. Must be in the range 0-5. axis (int): The axis along which the spline filter is applied. Default is the last axis. output (cupy.ndarray or dtype, optional): The array in which to place the output, or the dtype of the returned array. Default is ``numpy.float64``. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``, ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``). Returns: cupy.ndarray: The result of prefiltering the input. .. seealso:: :func:`scipy.spline_filter1d` rr spline order not supportedintr$ )r index_type data_type pole_type block_size)rFr!) RuntimeErrorndimr_normalize_axis_indexshaper _get_outputrr.r9r&_scalar get_typenamer$real _get_inttypeint32int64sizearraymaxmathceilnumpylog2r get_raw_spline1d_kernel get_polesget_gainr)r*r/)r2raxisr3rxrI run_kernelr8 data_dtyper7rErFrD index_dtype n_samples n_signalsinforGkernblockgridpoless rspline_filter1driGs]6 qyyEAII7888 A 6D  )$ 5 5DaiD16Q;D!'$-12DEJ "6511 q&))) %76%B%B"D*l "// ;;I "// @@I#E**J *e 3 3$**K I)#I :y),qw6k J J JDQ$)EJy2~$>$>???CCJ ! 9      DME q !A %%( 2 4D # ,5 9 9 9E " +E 2 22D DutTl###&$,''D,>,> tV,,, ;;|%; 0 00rc|dks|dkrtd|}t||\}}}|dvr8|jdkr-t|jD]}t ||||||}t |t jrtj ||n|}|j |kr| |}|S)aMultidimensional spline filter. Args: input (cupy.ndarray): The input array. order (int): The order of the spline interpolation, default is 3. Must be in the range 0-5. output (cupy.ndarray or dtype, optional): The array in which to place the output, or the dtype of the returned array. Default is ``numpy.float64``. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``, ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``). Returns: cupy.ndarray: The result of prefiltering the input. .. seealso:: :func:`scipy.spline_filter1d` r>r r=)rr?rr3r) rHr9rIrangerir)r&r*rr.r$r/) r2rr3rr^r8r`r7r]s r spline_filterrms( qyyEAII7888 A%76%B%B"D*l FuzA~~!&MM  D Aud4d C C C CAA&$,'' tV,,,, ||##|,, MrTc4|jjdkrc|r%tj|jtj}n$tj|jtj}||d}n|jjdvrg|dkr`|r%tj|jtj}n$tj|jtj}||}ntd|jj stj |}|S)NfFr!iur?z,coordinates should have floating point dtype) r$r%r&r+r(float64r/rr,r-r0) coordinatesr allow_float32 coord_dtypes r_check_coordinatesrus $$  N,[-> MMKK,[-> MMK!((5(AA   4 ' ' 199 "0%t| #0%t| &,,[99KGHHH   ):,[99 rc|dvr>d}|dkrtd|}ntd}tj||fi|}nd}|}||fS) N)rr r r )rconstant_valuesedge)rr)dictr&pad)r2rcvalnpadkwargspaddeds r_prepad_for_spline_filterrsq +++ ? " "z4@@@FFv&&&F%0000 4<rc|r|dkrtj|dfSt|||\}}tj|jtj}t ||||}tj||fS)akPerform spline prefiltering when needed. Spline orders > 1 need a prefiltering stage to preserve resolution. For boundary modes without analytical spline boundary conditions, some prepadding of the input with cupy.pad is used to maintain accuracy. ``npad`` is an integer corresponding to the amount of padding at each edge of the array. r>rrk)r&r0rr+r$r(rm) image prefilterrr|rrr}r6filtereds r _filter_inputrs 2 &u--q11,UD$??LFD$U[$,??KVU;TJJJH  !( + +T 11rr c td|||dks|dkr8tj|dg|jzd|}tj|d}d}t j|||jdd}|jj d v}t j ||||jj d vr| tj }t||}t|||||\} } tt!|j|jd d k} t#j|j| |j||||| } | | |||S) a6Map the input array to new coordinates by interpolation. The array of coordinates is used to find, for each point in the output, the corresponding coordinates in the input. The value of the input at those coordinates is determined by spline interpolation of the requested order. The shape of the output is derived from that of the coordinate array by dropping the first axis. The values of the array along the first axis are the coordinates in the input array at which the output value is found. Args: input (cupy.ndarray): The input array. coordinates (array_like): The coordinates at which ``input`` is evaluated. output (cupy.ndarray or ~cupy.dtype): The array in which to place the output, or the dtype of the returned array. order (int): The order of the spline interpolation, default is 3. Must be in the range 0-5. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``, ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``). cval (scalar): Value used for points outside the boundaries of the input if ``mode='constant'`` or ``mode='opencv'``. Default is 0.0 prefilter (bool): Determines if the input array is prefiltered with ``spline_filter`` before interpolation. The default is True, which will create a temporary ``float64`` array of filtered values if ``order > 1``. If setting this to False, the output will be slightly blurred if ``order > 1``, unless the input is prefiltered, i.e. it is the result of calling ``spline_filter`` on the original input. Returns: cupy.ndarray: The result of transforming the input. The shape of the output is derived from that of ``coordinates`` by dropping the first axis. .. seealso:: :func:`scipy.ndimage.map_coordinates` map_coordinatesrr)r?r?r )rxr?Nrpr)yshaperr|rinteger_outputnprepad)rr&r{rIaddrrLrKr$r% _check_cvalr/r(rurrU_prodr_get_map_kernel) r2rrr3rrr|rretrrr large_intres rrrslV&t444 x4>115: 5z)-///h{A..   FE;+ 1``. If setting this to False, the output will be slightly blurred if ``order > 1``, unless the input is prefiltered, i.e. it is the result of calling ``spline_filter`` on the original input. texture_memory (bool): If True, uses GPU texture memory. Supports only: - 2D and 3D float32 arrays as input - ``(ndim + 1, ndim + 1)`` homogeneous float32 transformation matrix - ``mode='constant'`` and ``mode='nearest'`` - ``order=0`` (nearest neighbor) and ``order=1`` (linear interpolation) - NVIDIA CUDA GPUs Returns: cupy.ndarray or None: The transformed input. If ``output`` is given as a parameter, ``None`` is returned. .. seealso:: :func:`scipy.ndimage.affine_transform` z3HIP currently does not support texture accelerationrlinearr)datatransformation_matrix output_shaper3 interpolationr border_valueaffine_transformoffset)r?r>r?z no proper affine matrix providedr>Nr;zimproper affine shaper)r;r;r]rrArKFr!rprr|rrr)$ris_hiprHraffine_transformationrr_fix_sequence_argrIfloatrKr&zeroslinalginvrolldiagindicesrqdotreshape expand_dimsasarrayrLrr$r/r%r(rrrUrr_get_zoom_shift_kernel_get_affine_kernel)r2matrixrrr3rrr|rr tm_interpmrrrrIrrrrres rrr?s(H A > GEGG G % HHy -5DJ;G5;>> {a <?fl1o1 1 1AAArE]FAAAssF^FF \!_ Q . .CRCG_FCRC"H%F 11 ;!  Yv&&Fl 1``. If setting this to False, the output will be slightly blurred if ``order > 1``, unless the input is prefiltered, i.e. it is the result of calling ``spline_filter`` on the original input. Returns: cupy.ndarray or None: The rotated input. .. seealso:: :func:`scipy.ndimage.rotate` rotaterrrr?z invalid rotation plane specifiedrg?r>rA)rlistrIrrXdeg2radrVsincosrTrrKptpr/r&rRtupleidentityrrqr)r2angleaxesrr3rrr|r input_arrrIradrr rot_matrix img_shapein_plane_shapeiyix out_boundsout_plane_shape out_center in_centerrrrs rrrsRXud+++ xI ::D Aw{{ Q9>! Aw{{ Q9>! AwaQa! Aw{{inQ//;<<< >D -  C (3--C (3--CsCj #tSk+,,J io..It_N *BAq"b>$%r1b>#33 !9Za888 &tz 2 2 $D/! 3q89J!#q(IL(L&&L ^D ! !F"F47DG "F47DG  #tF47DG "F47DG  [T\ 2 2 2Fz)F4L \& ! !F \& ! !F E66< $  3 33rc ptd||tj||jdt}|dkr\d}t |t j|j|jt j t j |d||||| }n!tj ||}|jj dvr| t j}t|||||\}}|jj dv} tj||| t#|jdk} t'j|j| |j|||| |} t j |t jd }|jd krt-d |j|jkrt-d | ||||S) aShift an array. The array is shifted using spline interpolation of the requested order. Points outside the boundaries of the input are filled according to the given mode. Args: input (cupy.ndarray): The input array. shift (float or sequence): The shift along the axes. If a float, ``shift`` is the same for each axis. If a sequence, ``shift`` should contain one value for each axis. output (cupy.ndarray or ~cupy.dtype): The array in which to place the output, or the dtype of the returned array. order (int): The order of the spline interpolation, default is 3. Must be in the range 0-5. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``, ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``). cval (scalar): Value used for points outside the boundaries of the input if ``mode='constant'`` or ``mode='opencv'``. Default is 0.0 prefilter (bool): Determines if the input array is prefiltered with ``spline_filter`` before interpolation. The default is True, which will create a temporary ``float64`` array of filtered values if ``order > 1``. If setting this to False, the output will be slightly blurred if ``order > 1``, unless the input is prefiltered, i.e. it is the result of calling ``spline_filter`` on the original input. Returns: cupy.ndarray or None: The shifted input. .. seealso:: :func:`scipy.ndimage.shift` shiftrrNrprrC)r$rr?zshift must be 1dz len(shift) must equal input.ndim)rrrrIrrr&onesr$negativerrLr%r/r(rrrrKr_get_shift_kernelrqrrS) r2rr3rrr|rrrrrres rrrGsNWeT***  #E5:w F FE x!  Iej%+ . . M$,u-- . .         "6511 ; t # #LL..E)%D$NN'*d2 $n555%+&&0 0 J 5;4u)7<<< U$,cBBB :??/00 0 : & &?@@ @ Xuf%%% Mr) grid_modec  td||tj||jdt}g}t |j|D]7\} } |tt| | z8t|}|dkrg}g} t |j|D]|\} } | dkrG|t | | z | |ddz dz R|d| d}d}t|tj || |||||| }n|r0d}|d krd }n|d krd }|tjd |d|dg}t |j|D]`\} } |r| dkr|| | z &| dkr|| dz | dz z K|datj|||}|jjdvr|tj}t+|||||\}}|jjdv}tj|||t/t1|jt1|dk}t3j|j|||||||}tj |tj}|||||S)a Zoom an array. The array is zoomed using spline interpolation of the requested order. Args: input (cupy.ndarray): The input array. zoom (float or sequence): The zoom factor along the axes. If a float, ``zoom`` is the same for each axis. If a sequence, ``zoom`` should contain one value for each axis. output (cupy.ndarray or ~cupy.dtype): The array in which to place the output, or the dtype of the returned array. order (int): The order of the spline interpolation, default is 3. Must be in the range 0-5. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``, ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``). cval (scalar): Value used for points outside the boundaries of the input if ``mode='constant'`` or ``mode='opencv'``. Default is 0.0 prefilter (bool): Determines if the input array is prefiltered with ``spline_filter`` before interpolation. The default is True, which will create a temporary ``float64`` array of filtered values if ``order > 1``. If setting this to False, the output will be slightly blurred if ``order > 1``, unless the input is prefiltered, i.e. it is the result of calling ``spline_filter`` on the original input. grid_mode (bool, optional): If False, the distance from the pixel centers is zoomed. Otherwise, the distance including the full pixel extent is used. For example, a 1d signal of length 5 is considered to have length 4 when ``grid_mode`` is False, but length 5 when ``grid_mode`` is True. See the following visual illustration: .. code-block:: text | pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 | |<-------------------------------------->| vs. |<----------------------------------------------->| The starting point of the arrow in the diagram above corresponds to coordinate location 0 in each mode. Returns: cupy.ndarray or None: The zoomed input. .. seealso:: :func:`scipy.ndimage.zoom` zoomrrr;r?g@rNr r rrz It is recommended to use mode = z instead of z when grid_mode is True.rrpr)rrrrrA)rrrrIrziprKappendr@roundrrr&rrrrLr$r%r/r(rrrUrr_get_zoom_kernelrq)r2rr3rrr|rrrszrin_sizeout_size suggest_moderrrrres rrrs[hVUD)))  "4VU C CDLEK&&//1Ca!e --....&&L x!$U[,!?!? ! ! GX!|| E'NNX5666 tBx!|s23333 A a    !  L              : Lz!!. * ' 9|99999:::!$U[,!?!?   GX X\\ Gh.////A Wq[X\:;;;; A"65 EEE ; t # #LL..E)%D$NN'*d2 $n555ek**E,,?,?@@7J / J <U)Y|D 555 XtV$$$ Mr)T)Nr:r rT)rNNr:r rT)rTNr:r rT)rVrr&rXr cupy._corer cupy.cudarcupyxrcupyx.scipy.ndimagerrr prodrrr9rqrirmrurrrrrrrrrrrrs4  %%%%%%//////666666   M M M$+$+$+N"#DL!Q1Q1Q1Q1h !H####L4   222$<=9=@@@@FKOCGS$)SSSSSl   HI04c3c3c3c3LEHJJJJZCFx&+xxxxxxxr