`ipddlZddlZddlZddlmZddlmZd0dZdZdZdZdZ d Z d Z d Z ej d d ddZej dd ddZd1dZej ddddZ d2dZd3dZd0dZd0dZd0dZd0dZd0dZd Zd!Zd"Zd#Z d4d$Zd0d%Zd0d&Zd0d'Z d0d(Z!d0d)Z"d0d*Z#d0d+Z$ d5d,Z%d0d-Z&ddd.d/Z'dS)6N)_core)_utilc^t|tjstd|jjdvrtd|t |jd}n.t|tjrtj|}tj |t}|j|jkrtd|j D]}|dkrtd t|tjr"|j |j krtd d }nCd }|%tj|j tj}ntj|j |}|jd krd }n|jd kr2|d krd nd}||nw|jtjkr%tj|j tj}n|}t)|||}|jtjkrt+j|||r|S||fS)aLabels features in an array. Args: input (cupy.ndarray): The input array. structure (array_like or None): A structuring element that defines feature connections. ```structure``` must be centersymmetric. If None, structure is automatically generated with a squared connectivity equal to one. output (cupy.ndarray, dtype or None): The array in which to place the output. Returns: label (cupy.ndarray): An integer array where each unique feature in ```input``` has a unique label in the array. num_features (int): Number of features found. .. warning:: This function may synchronize the device. .. seealso:: :func:`scipy.ndimage.label` input must be cupy.ndarrayFDzComplex type not supportedNdtypez(structure and input must have equal rankz'structure dimensions must be equal to 3zoutput shape not correctTFr) isinstancecupyndarray TypeErrorr char_generate_binary_structurendimasnumpynumpyarraybool RuntimeErrorshape ValueErroremptyint32sizeitemfill_labelrelementwise_copy)input structureoutputicaller_provided_outputmaxlabelys u/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/ndimage/_measurements.pylabelr) s. eT\ * *64555 {44555.uz1== It| , ,,L++  IT222I~##EFFF _HH 66FGG G &$,'' 5 <5; & &788 8!%!& >Z U[99FFZ V44F zQ q ))11q H <5; & & 5; 44AAA%A.. <5; & &  "1f - - - xc|dkrd}|dkrtjdtStjtjdg|zdz }tj|d}||kS)NrTr r r)rrrfabsindicesaddreduce)rank connectivityr#s r(rrQsva  axx{4t,,,, Z qcDj11A5 6 6F Y  fa ( (F \ !!r*c tj|dk fdtjD d}tdjD]}|dz |z}tj|dkd} fd|D}t j|tj}|jd}t j|jtj}t jdtj} t|t|||j||j t|| |j t| d} t j| tj} t|| | |j t!| t j| ||j | S) Nrc&g|] }|dz Sr).0dmelemss r( z_label..]s! 2 2 2bE"IM 2 2 2r*rr cTg|]#fdtjD$S)c,g|]}|Sr5r5)r6r7drvecss r(r9z%_label...bs! 2 2 2bT"Xb\ 2 2 2r*)ranger)r6r<r=xs @r(r9z_label..bs: C C Cr 2 2 2 2 2E!&MM 2 2 2 C C Cr*r )r)rwherer>rr rrrzeros _kernel_init_kernel_connectr _kernel_countintr_kernel_labels_kernel_finalizesort)r?r"r'offsetr7indxsdirsndirsy_shapecountr&labelsr8r=s` @@r(rr[s K Q ' 'E 2 2 2 2E!&MM 2 2 2D !WFAqv''!d2h& K # #A &E C C C C CU C C CD :d%+ . . .D KNEj 444G Jq , , ,ELNN1aOgtUAFAAFCCCCMOOAu16****58}}H Z 4 4 4FNQvAF3333x6!2!2AAFCCCC Or*c0tjddddS)NzX xzY yz'if (x == 0) { y = -1; } else { y = i; }cupyx_scipy_ndimage_label_initrElementwiseKernelr5r*r(rCrCqs"  " u?( * **r*c0tjddddS)Nz8raw int32 shape, raw int32 dirs, int32 ndirs, int32 ndimzraw Y yaq if (y[i] < 0) continue; for (int dr = 0; dr < ndirs; dr++) { int j = i; int rest = j; int stride = 1; int k = 0; for (int dm = ndim-1; dm >= 0; dm--) { int pos = rest % shape[dm] + dirs[dm + dr * ndim]; if (pos < 0 || pos >= shape[dm]) { k = -1; break; } k += pos * stride; rest /= shape[dm]; stride *= shape[dm]; } if (k < 0) continue; if (y[k] < 0) continue; while (1) { while (j != y[j]) { j = y[j]; } while (k != y[k]) { k = y[k]; } if (j == k) break; if (j < k) { int old = atomicCAS( &y[k], k, j ); if (old == k) break; k = old; } else { int old = atomicCAS( &y[j], j, k ); if (old == j) break; j = old; } } } !cupyx_scipy_ndimage_label_connectrSr5r*r(rDrDws)  "B# H ,O' -' -'-r*c0tjddddS)Nzraw Y y, raw int32 countz if (y[i] < 0) continue; int j = i; while (j != y[j]) { j = y[j]; } if (j != i) y[i] = j; else atomicAdd(&count[0], 1); cupyx_scipy_ndimage_label_countrSr5r*r(rErEs'  " &  * + + +r*c0tjddddS)NrXz*raw Y y, raw int32 count, raw int32 labelszj if (y[i] != i) continue; int j = atomicAdd(&count[1], 1); labels[j] = i; cupyx_scipy_ndimage_label_labelsrSr5r*r(rGrGs'  " 8 + , ,,r*c0tjddddS)Nzint32 maxlabelzraw int32 labels, raw Y ya if (y[i] < 0) { y[i] = 0; continue; } int yi = y[i]; int j_min = 0; int j_max = maxlabel - 1; int j = (j_min + j_max) / 2; while (j_min < j_max) { if (yi == labels[j]) break; if (yi < labels[j]) j_max = j - 1; else j_min = j + 1; j = (j_min + j_max) / 2; } y[i] = j + 1; "cupyx_scipy_ndimage_label_finalizerSr5r*r(rHrHs'  "5 " -' . ..r*z=T input, R labels, raw X index, uint64 size, raw float64 meanzraw float64 outz for (ptrdiff_t j = 0; j < size; j++) { if (labels == index[j]) { atomicAdd(&out[j], (input - mean[j]) * (input - mean[j])); break; } } cupyx_scipy_ndimage_variancez+T input, R labels, raw X index, uint64 sizez for (ptrdiff_t j = 0; j < size; j++) { if (labels == index[j]) { atomicAdd(&out[j], input); break; } } cupyx_scipy_ndimage_sumcDtd|j|D]}|||||zdd|jzzk}t tdd|jz}t j||d|||||z<|S)Nrr4raxis)r>rreshapertupler rAsum)r!rPindexsum_val batch_sizer$matchedsum_axess r(_ndimage_sum_kernel_2rns 1ej* - -E!A N"23;; D5:% %'''q!ej.1122$(Jwq$A$A$E$E%F%%!j. !! Nr*z!raw float64 out, raw uint64 countz for (ptrdiff_t j = 0; j < size; j++) { if (labels == index[j]) { atomicAdd(&out[j], input); atomicAdd(&count[j], 1); break; } } cupyx_scipy_ndimage_meanFctj|tj}tj|tj}t d|j|D]}|||||zdd|jzzk}tt dd|jz} | | ||||z<tj ||d | ||||z<|r||z |fS||z S)Nr rrbr4rrd) r empty_likefloat64uint64r>rrfrrgrhrA) r!rPrirk return_countrjrOr$rl mean_axess r(_ndimage_mean_kernel_2rvs oe4<888G OE 5 5 5E 1ej* - -E!A N"23;; D5:% %'''%1uz>2233 ")++9+"="=aJ$(Jwq$A$A$E$E%F%%!j. !!&%% U?r*c|rt||||Stj|tj}tj|tj}t ||||j||\}}|r||z |fS||z S)N)rtr )rvr zeros_likerrrs_ndimage_mean_kernelr)r!rPrirtuse_kernoutrOrhs r( _mean_driverr|sA%eVU3?AAA A /% . .C OE 5 5 5E%e&,eUZeMMJC"U{E!! ;r*c t|tjstd|jtjtjfvr,td|jjd}|jtj tj tj tj tj tjtjfvr*t!jd|jdt$jd}d}| ||St|tjstd tj||\}}||||d kStj|r||||kSt|tjsat|t,std |||ktj d St3|||d|\}}|rd gdt5|jDR}tj|d||ktj|||z d t?t5d|jdz|z Stj |tj }tC||||j"|||z S)atCalculates the variance of the values of an n-D image array, optionally at specified sub-regions. Args: input (cupy.ndarray): Nd-image data to process. labels (cupy.ndarray or None): Labels defining sub-regions in `input`. If not None, must be same shape as `input`. index (cupy.ndarray or None): `labels` to include in output. If None (default), all values where `labels` is non-zero are used. Returns: cupy.ndarray: Values of variance, for each sub-region if `labels` and `index` are specified. .. seealso:: :func:`scipy.ndimage.variance` rz0cupyx.scipy.ndimage.variance doesn't support %{}Fz:Using the slower implementation because the provided type z is not supported by cupyx.scipy.ndimage.sum. Consider using an array of type int32, float16, float32, float64, uint32, uint64 as data types for the fast implementationTc||z }|j}tj|tj|tz SN)meanrr squarerh asanyarrayastypefloat)r!vals_crOs r( calc_var_with_intermediate_floatz2variance..calc_var_with_intermediate_floatIsV% {6""&&((4?5+A+A+H+H+O+OOOr*Nlabel must be cupy.ndarrayr*index must be cupy.ndarray or a scalar intcopy.c3.K|]}tjVdSr)r newaxis)r6_s r( zvariance..gs$CCA4<CCCCCCr*)N.rr )#r r rrr complex64 complex128formattyperfloat16float32rruint32rs ulonglongwarningswarnrPerformanceWarningbroadcast_arraysisscalarrFvarrr|r>rrArrhrgrx_ndimage_variance_kernelr) r!rPrirzrmean_valrOnew_axisr{s r(variancer$s" eT\ * *64555 {t~t777!6%+"23355 5H {4:t|T\<dk>+++   *K * * *,1+C  E E E PPP~//666 fdl + +64555)%88ME6 }//fqj0ABBB }UH//fo0FGGG eT\ * *E%%% EHII I&E/*//1188>C9EE E#5&%xHHOHeJDCCuz1B1BCCCDDz&+uX>+ehx.@&@AA SuQ Q'?'?!@!@AAEJ J /%t| 4 4 4C #E65%*h$' ) )+0 11r*ct|tjstd|jtjtjfvr,td|jjd}|jtj tj tj tj tj tjtjfvr!t!jdt$jd}||St|tjstdtj||\}}|||dkSt|tjsBt|t,std |||kS|jdkr tjgtj Stj|tj }|jd kr |jd ks|rt7||||St9||||j|S) asCalculates the sum of the values of an n-D image array, optionally at specified sub-regions. Args: input (cupy.ndarray): Nd-image data to process. labels (cupy.ndarray or None): Labels defining sub-regions in `input`. If not None, must be same shape as `input`. index (cupy.ndarray or None): `labels` to include in output. If None (default), all values where `labels` is non-zero are used. Returns: sum (cupy.ndarray): sum of values, for each sub-region if `labels` and `index` are specified. .. seealso:: :func:`scipy.ndimage.sum_labels` rz,cupyx.scipy.ndimage.sum does not support %{}FzUsing the slower implementation as cupyx.scipy.ndimage.sum supports int32, float16, float32, float64, uint32, uint64 as data typesfor the fast implmentationTNrrrr ir`)r r rrr rrrrrrrrrrrsrrrrrrhrrFrrint64rxrn_ndimage_sum_kernel)r!rPrirzr{s r( sum_labelsrps " eT\ * *64555 {t~t777FMM K  H {4:t|T\<dk>+++   )+0*B  D D D  ~yy{{ fdl + +64555)%88ME6 }Vq[!%%''' eT\ * *2%%% 2HII I&E/*//11 1 zQz"DJ//// /%t| 4 4 4C  fqX$UFE3??? ufeUZ E EEr*c$t|||S)aCalculates the sum of the values of an n-D image array, optionally at specified sub-regions. Args: input (cupy.ndarray): Nd-image data to process. labels (cupy.ndarray or None): Labels defining sub-regions in `input`. If not None, must be same shape as `input`. index (cupy.ndarray or None): `labels` to include in output. If None (default), all values where `labels` is non-zero are used. Returns: sum (cupy.ndarray): sum of values, for each sub-region if `labels` and `index` are specified. Notes: This is an alias for `cupyx.scipy.ndimage.sum_labels` kept for backwards compatibility reasons. For new code please prefer `sum_labels`. .. seealso:: :func:`scipy.ndimage.sum` )rr!rPris r(rhrhs, eVU + ++r*ct|tjstd|jtjtjfvr,td|jjd}|jtj tj tj tj tj tjtjfvr!t!jdt$jd}d}| ||St|tjstdtj||\}}||||d kStj|r||||kSt|tjsNt|t,std |||ktj St1|||| S) asCalculates the mean of the values of an n-D image array, optionally at specified sub-regions. Args: input (cupy.ndarray): Nd-image data to process. labels (cupy.ndarray or None): Labels defining sub-regions in `input`. If not None, must be same shape as `input`. index (cupy.ndarray or None): `labels` to include in output. If None (default), all values where `labels` is non-zero are used. Returns: mean (cupy.ndarray): mean of values, for each sub-region if `labels` and `index` are specified. .. seealso:: :func:`scipy.ndimage.mean` rz-cupyx.scipy.ndimage.mean does not support %{}FzUsing the slower implementation as cupyx.scipy.ndimage.mean supports int32, float16, float32, float64, uint32, uint64 as data types for the fast implmentationTc|}|j}|tj|t z Sr)rhrr rrr)r!rhrOs r(!calc_mean_with_intermediate_floatz/mean..calc_mean_with_intermediate_floats;iikk T_U++2259999r*Nrrrr )rz)r r rrr rrrrrrrrrrrsrrrrrrrrFrr|)r!rPrirzrs r(rrs$ eT\ * *64555 {t~t777GNN K  H {4:t|T\<dk>+++   )+0*B  D D D :::~00777 fdl + +64555)%88ME6 }00vz1BCCC }UI00v1GHHH eT\ * *E%%% EHII I&E/*00t|0DD D vux @ @ @@r*cHtjt|||S)aCalculates the standard deviation of the values of an n-D image array, optionally at specified sub-regions. Args: input (cupy.ndarray): Nd-image data to process. labels (cupy.ndarray or None): Labels defining sub-regions in `input`. If not None, must be same shape as `input`. index (cupy.ndarray or None): `labels` to include in output. If None (default), all values where `labels` is non-zero are used. Returns: standard_deviation (cupy.ndarray): standard deviation of values, for each sub-region if `labels` and `index` are specified. .. seealso:: :func:`scipy.ndimage.standard_deviation` )r sqrtrrs r(standard_deviationr s " 9XeVU33 4 44r*ctjtj}tj|tjo |j|kp)tj|tjo |j|k}|S)zCTest whether the NumPy data type `dt` can be safely cast to an int.)r r rFitemsize issubdtype signedintegerunsignedinteger)dtint_sizesafes r(_safely_castable_to_intr s`z#'H D.//KBK84K P /"d2 3 3 N h8N  Kr*cb|djtjfd|DS)ztConcatenated result of applying func to a list of arrays. func should be cupy.min, cupy.max or cupy.median rcng|]1}|jdkr |dntjdg2SrT)keepdimsr )rr asarray)r6ar funcs r(r9z_get_values..0s^   v{{ DT " " " " $ aS > > >   r*)r r concatenate)arraysrr s `@r( _get_valuesr)sS 1IOE            r*c`tjfdt||DS)zpConcatenated positions from applying arg_func to arrays. arg_func should be cupy.argmin or cupy.argmax cg|]?\}}|jdkr||dntjdgt@Sr)rr rrF)r6posrarg_funcs r(r9z"_get_positions..>sg   Qv{{ T*** + + $ aS < < <   r*)r rzip)rposition_arraysrs `r(_get_positionsr8sL      ov66     r*c |p|} g} g} |D]@} || k} | || | r| || Ag}|r|t| tjgz }|r|t | | tjgz }|r|t| tjgz }|r|t | | tjgz }|r|t| tjgz }|S)zInternal helper routine for _select. With relatively few labels it is faster to call this function rather than using the implementation based on cupy.lexsort. ) appendrr minrargminmaxargmaxmedian)r!rPidxs positionsfind_minfind_min_positionsfind_maxfind_max_positions find_medianfind_positionsrrr$ label_idxresults r(_select_via_loopingrFs!(=+=NFO 99aK  eI&'''  9  " "9Y#7 8 8 8 F2;vtx0011I>&/4;GGHH2;vtx0011I>&/4;GGHH5;vt{3344 Mr*c  p}d} |r1tj|j|j} fd} | | || Stj||\}}|$|dk} d} |r| | } | || | Stj|r$||k} d} |r| | } | || | Stj|}t|j } | }| }| r|dks ||jkrItj |d\}}tj ||}d|||jk<|||k}n9tj|t}|dk||kz}|dz||<|}|}|r| } t$jjtjv}|r |srd}nd}nd}|r*t-||krt/||||  Stjtj||f}||}||}|r| |} tj |tjd|d z}ssr |dd }ssr |dddz }g}rYtjt| d z|j }|||||<|||gz }r^tj| d zt}| ||||<|||gz }rYtjt| d z|j }|||||<|||gz }r^tj| d zt}| ||||<|||gz }rLtjt-|}tjt| d zt}|||||<tjt| d zt} ||| ||<||}| |} | |z d z}!||!z }| |!z} |j jd vrI|||t<|| t<zd z gz }n||||| zd z gz }|S) aReturn one or more of: min, max, min position, max position, median. If neither `labels` or `index` is provided, these are the global values in `input`. If `index` is None, but `labels` is provided, a global value across all non-zero labels is given. When both `labels` and `index` are provided, lists of values are provided for each labeled region specified in `index`. See further details in :func:`cupyx.scipy.ndimage.minimum`, etc. Used by minimum, maximum, minimum_position, maximum_position, extrema. NcPg}r||gz }r(||||kdgz }r||gz }r(||||kdgz }r|tj|gz }|SNr)rrr r)valsrrrrrrrs r( single_groupz_select..single_group{s  # txxzzl "F  9 y!34Q78 8F  # txxzzl "F  9 y!34Q78 8F  * t{4(() )F r*rT)return_inverserr@rciubg@)r arangerrfrrrrrr rrunique searchsortedrrFrravelr _acceleratorACCELERATOR_CUBget_routine_acceleratorslenrlexsortstackrBrkindrr)"r!rPrirrrrrrrrmaskmasked_positionssafe_int min_label max_label unique_labelsrfound using_cubn_label_cutofforderlabel_change_index min_index max_indexrminsminposmaxsmaxposlocslohisteps" ````` r(_selectrhs3(=+=NIAK ++33EK@@          ~|E9---)%88ME6 }z  /( |E$K)9::: }U;  /( |E$K)9::: L  E&v|44H I I  2 A V[)@)@ $ F4 H H H v 66,-T]' '(d#u,uc**//11ty01q=D%L KKMME \\^^F&OO%% "2 ++--.I  [ NNNN #d))~55" 64H6H (+   LU[[]]FLLNN$CDD E EE %LE E]F%e$ *6+/;q)a-+H+HJJ,%,,&ss+ /%//&qrr*Q. Fz#fjjll++a/=="' "2VI 4:,!FJJLL--//!3S99$-i$8vi !6$<. z#fjjll++a/=="' "2VI 4:,!FJJLL--//!3S99$-i$8vi !6$<. 6{3v;;'' ZFJJLL))A-s 3 3 $Y6)  ZFJJLL))A-s 3 3 $Y6)  X X RA~ d  d  ; u $ $ b ((//%)2B2B52I2II FF b E"I-45 5F Mr*c4t|||ddS)aCalculate the minimum of the values of an array over labeled regions. Args: input (cupy.ndarray): Array of values. For each region specified by `labels`, the minimal values of `input` over the region is computed. labels (cupy.ndarray, optional): An array of integers marking different regions over which the minimum value of `input` is to be computed. `labels` must have the same shape as `input`. If `labels` is not specified, the minimum over the whole array is returned. index (array_like, optional): A list of region labels that are taken into account for computing the minima. If `index` is None, the minimum over all elements where `labels` is non-zero is returned. Returns: cupy.ndarray: Array of minima of `input` over the regions determined by `labels` and whose index is in `index`. If `index` or `labels` are not specified, a 0-dimensional cupy.ndarray is returned: the minimal value of `input` if `labels` is None, and the minimal value of elements where `labels` is greater than zero if `index` is None. .. seealso:: :func:`scipy.ndimage.minimum` T)rrrrs r(minimumr 2 5&%$ 7 7 7 ::r*c4t|||ddS)aCalculate the maximum of the values of an array over labeled regions. Args: input (cupy.ndarray): Array of values. For each region specified by `labels`, the maximal values of `input` over the region is computed. labels (cupy.ndarray, optional): An array of integers marking different regions over which the maximum value of `input` is to be computed. `labels` must have the same shape as `input`. If `labels` is not specified, the maximum over the whole array is returned. index (array_like, optional): A list of region labels that are taken into account for computing the maxima. If `index` is None, the maximum over all elements where `labels` is non-zero is returned. Returns: cupy.ndarray: Array of maxima of `input` over the regions determaxed by `labels` and whose index is in `index`. If `index` or `labels` are not specified, a 0-dimensional cupy.ndarray is returned: the maximal value of `input` if `labels` is None, and the maximal value of elements where `labels` is greater than zero if `index` is None. .. seealso:: :func:`scipy.ndimage.maximum` T)rrrrs r(maximumr#rr*c4t|||ddS)aCalculate the median of the values of an array over labeled regions. Args: input (cupy.ndarray): Array of values. For each region specified by `labels`, the median values of `input` over the region is computed. labels (cupy.ndarray, optional): An array of integers marking different regions over which the median value of `input` is to be computed. `labels` must have the same shape as `input`. If `labels` is not specified, the median over the whole array is returned. index (array_like, optional): A list of region labels that are taken into account for computing the medians. If `index` is None, the median over all elements where `labels` is non-zero is returned. Returns: cupy.ndarray: Array of medians of `input` over the regions determined by `labels` and whose index is in `index`. If `index` or `labels` are not specified, a 0-dimensional cupy.ndarray is returned: the median value of `input` if `labels` is None, and the median value of elements where `labels` is greater than zero if `index` is None. .. seealso:: :func:`scipy.ndimage.median` T)rrrrs r(rr?s 2 5&%T : : :1 ==r*c tj|j}tjdgt |dddzddd}t |||dd}|jdkrt|}ntj |}tj |rt||z|zSd| dd|z|zDS)aFind the positions of the minimums of the values of an array at labels. For each region specified by `labels`, the position of the minimum value of `input` within the region is returned. Args: input (cupy.ndarray): Array of values. For each region specified by `labels`, the minimal values of `input` over the region is computed. labels (cupy.ndarray, optional): An array of integers marking different regions over which the position of the minimum value of `input` is to be computed. `labels` must have the same shape as `input`. If `labels` is not specified, the location of the first minimum over the whole array is returned. The `labels` argument only works when `index` is specified. index (array_like, optional): A list of region labels that are taken into account for finding the location of the minima. If `index` is None, the ``first`` minimum over all elements where `labels` is non-zero is returned. The `index` argument only works when `labels` is specified. Returns: Tuple of ints or list of tuples of ints that specify the location of minima of `input` over the regions determined by `labels` and whose index is in `index`. If `index` or `labels` are not specified, a tuple of ints is returned specifying the location of the first minimal value of `input`. .. note:: When `input` has multiple identical minima within a labeled region, the coordinates returned are not guaranteed to match those returned by SciPy. .. seealso:: :func:`scipy.ndimage.minimum_position` rNrrcT)rc,g|]}t|Sr5rgr6vs r(r9z$minimum_position.. I I IE!HH I I Ir* rrrcumprodlistrrrFr rrrgrfr!rPridimsdim_prodrs r(minimum_positionr[N = % %D}aS4UaU #4#4455ddd;H UFEd C C CA FF{aVf%% }V2f(D0111 I Iv~~b!44@DH I I IIr*c tj|j}tjdgt |dddzddd}t |||dd}|jdkrt|}ntj |}tj |rt||z|zSd| dd|z|zDS)aFind the positions of the maximums of the values of an array at labels. For each region specified by `labels`, the position of the maximum value of `input` within the region is returned. Args: input (cupy.ndarray): Array of values. For each region specified by `labels`, the maximal values of `input` over the region is computed. labels (cupy.ndarray, optional): An array of integers marking different regions over which the position of the maximum value of `input` is to be computed. `labels` must have the same shape as `input`. If `labels` is not specified, the location of the first maximum over the whole array is returned. The `labels` argument only works when `index` is specified. index (array_like, optional): A list of region labels that are taken into account for finding the location of the maxima. If `index` is None, the ``first`` maximum over all elements where `labels` is non-zero is returned. The `index` argument only works when `labels` is specified. Returns: Tuple of ints or list of tuples of ints that specify the location of maxima of `input` over the regions determaxed by `labels` and whose index is in `index`. If `index` or `labels` are not specified, a tuple of ints is returned specifying the location of the first maximal value of `input`. .. note:: When `input` has multiple identical maxima within a labeled region, the coordinates returned are not guaranteed to match those returned by SciPy. .. seealso:: :func:`scipy.ndimage.maximum_position` rNrrcT)rc,g|]}t|Sr5r r s r(r9z$maximum_position..rr*rrs r(maximum_positionrrr*c tj|j}tjdgt |dddzddd}t |||dddd\}}}}|jdkrT|}|}||t||z|zt||z|zfStj |}tj |}d| dd|z|zD}d| dd|z|zD}||||fS) aCalculate the minimums and maximums of the values of an array at labels, along with their positions. Args: input (cupy.ndarray): N-D image data to process. labels (cupy.ndarray, optional): Labels of features in input. If not None, must be same shape as `input`. index (int or sequence of ints, optional): Labels to include in output. If None (default), all values where non-zero `labels` are used. Returns: A tuple that contains the following values. **minimums (cupy.ndarray)**: Values of minimums in each feature. **maximums (cupy.ndarray)**: Values of maximums in each feature. **min_positions (tuple or list of tuples)**: Each tuple gives the N-D coordinates of the corresponding minimum. **max_positions (tuple or list of tuples)**: Each tuple gives the N-D coordinates of the corresponding maximum. .. seealso:: :func:`scipy.ndimage.extrema` rNrrcT)rrrrc,g|]}t|Sr5r r s r(r9zextrema..+ar*c,g|]}t|Sr5r r s r(r9zextrema..rr*) rrrrrrrrrgr rrf) r!rPrirrminimums min_positionsmaximums max_positionss r(extremar#s4 ;u{ # #D}aS4UaU #4#4455ddd;H7>  8884HmX}Q%**,, %**,,   =H,4 5 5 =H,4 5 5   L//ML//M(00Q778CtKM(00Q778CtKM X}m ;;r*cttjdjDfdt jD}t |dtjo|djdk}|rtd|DSdtj |dDS)a Calculate the center of mass of the values of an array at labels. Args: input (cupy.ndarray): Data from which to calculate center-of-mass. The masses can either be positive or negative. labels (cupy.ndarray, optional): Labels for objects in `input`, as enerated by `ndimage.label`. Only used with `index`. Dimensions must be the same as `input`. index (int or sequence of ints, optional): Labels for which to calculate centers-of-mass. If not specified, all labels greater than zero are used. Only used with `labels`. Returns: tuple or list of tuples: Coordinates of centers-of-mass. .. seealso:: :func:`scipy.ndimage.center_of_mass` c.g|]}td|S)r)slice)r6r$s r(r9z"center_of_mass..!s 999a 999r*czg|]7}t|tzz 8Sr5)rhrr)r6dirgridsrir!rP normalizers r(r9z"center_of_mass..#sQ  EE#J%%e,, ,fe<./s",,SS,,,,,,r*cg|]}|Sr5r5r s r(r9z"center_of_mass..1s 4 4 4!A 4 4 4r*rcrd) rhr ogridrr>rr rrgr)r!rPriresults is_0dim_arrayr)r*s``` @@r(center_of_massr1 s&UFE**J J99U[999 :E$$G 71:t|,,EA1E-,,G,,,,,, 4 4tz'333 4 4 44r*ctj|}tj|}|r1tj|j|j}`|td|s|S||S tj |\}n#t$rtdwxYw|7|s|dkS|dk|dkStj |}tj | j  |j |kr td|j dj d| j }|} |} | k| kz} | || }|r|| }} | || }|r|| }|} || fd}|t"kr!fd t%|jDn=tj|j|j jd vr t*jdd<|s||gn|||g|t"kr5tj| } fd | D}n1tj|j|}|tj| <|r|d}|S) aArray resulting from applying ``func`` to each labeled region. Roughly equivalent to [func(input[labels == i]) for i in index]. Sequentially applies an arbitrary function (that works on array_like input) to subsets of an N-D image array specified by `labels` and `index`. The option exists to provide the function with positional parameters as the second argument. Args: input (cupy.ndarray): Data from which to select `labels` to process. labels (cupy.ndarray or None): Labels to objects in `input`. If not None, array must be same shape as `input`. If None, `func` is applied to raveled `input`. index (int, sequence of ints or None): Subset of `labels` to which to apply `func`. If a scalar, a single value is returned. If None, `func` is applied to all non-zero values of `labels`. func (callable): Python function to apply to `labels` from `input`. out_dtype (dtype): Dtype to use for `result`. default (int, float or None): Default return value when a element of `index` does not exist in `labels`. pass_positions (bool, optional): If True, pass linear indices to `func` as a second argument. Returns: cupy.ndarray: Result of applying `func` to each of `labels` to `input` in `index`. .. seealso:: :func:`scipy.ndimage.labeled_comprehension` Nzindex without defined labelszMinput and labels must have the same shape (excepting dimensions with width 1)rz"Cannot convert index values from to (labels.dtype) without loss of precisionc j}tj d}tj d}tt |||D]"\}kr fd|D||<#dS)zlabels must be sortedleft)siderightc$g|] }| Sr5r5)r6inphighlows r(r9z9labeled_comprehension..do_map..s!???s3t8}???r*N)rr rrr>) inputsr#nidxrrr$r9r:rrP sorted_indexs @@r(do_mapz%labeled_comprehension..do_maps  v|& A A A  v|' B B Bd R44 A ALAsDd{{????????@F1II A Ar*ci|]}|Sr5r5)r6r$defaults r( z)labeled_comprehension..s666q7666r*fcc g|] }| Sr5r5)r6r$temps r(r9z)labeled_comprehension..s999a$q'999r*)r rrrrrfrrrr atleast_1danyrr rrargsortobjectr>rrrnanrrB)r!rPrir out_dtyper@pass_positions as_scalarrrrr label_order index_orderr>r#r=rDs ` ` ` @@r(labeled_comprehensionrO4sB e$$I L  EAK ++33EK@@  ~  ;<< < :4 && &4 y'8'899 9 -eV<< vv     2     } B4fqj)** *4fqj)9VaZ+@AA A OE " "E x V\**11%+>>%GHH j{{{FLLL *   LL & &E B B bLVr\ *DD\F $KE$dO ..""K K F + E+k* --//K%L A A A A A A AF6666E%*$5$5666z%+y11 ?tz$66iGQQQ )wy!4(((Fl;// 9999;#6#6#8#8999EK33,0t|K(() Ms CC7c vtj|||dzfd}t||||tddS)aCalculate the histogram of the values of an array, optionally at labels. Histogram calculates the frequency of values in an array within bins determined by `min`, `max`, and `bins`. The `labels` and `index` keywords can limit the scope of the histogram to specified sub-regions within the array. Args: input (cupy.ndarray): Data for which to calculate histogram. min (int): Minimum values of range of histogram bins. max (int): Maximum values of range of histogram bins. bins (int): Number of bins. labels (cupy.ndarray, optional): Labels for objects in `input`. If not None, must be same shape as `input`. index (int or sequence of ints, optional): Label or labels for which to calculate histogram. If None, all values where label is greater than zero are used. Returns: cupy.ndarray: Histogram counts. .. seealso:: :func:`scipy.ndimage.histogram` rc:tj|dSr)r histogram)r_binss r(_histzhistogram.._hists~dE**1--r*NF)rK)r linspacerOrH)r!rrbinsrPrirTrSs @r(rRrRs]0 M#sD1H - -E..... ! vueVT%   r*) ignore_valueadaptive_index_dtypec |jjdvrtd|rTtjt |jdz }tjt|jdz  | d}tj |}tj |d}|r| |d}tj ||j}|rt fd |D}d i}tj|}t!|D]<\} d kr | |kr z t fd |D|| < z =|S) a, Find indices of each distinct value in given array. Parameters ---------- arr : ndarray of ints Array containing integer values. ignore_value : int, optional This value will be ignored in searching the `arr` array. If not given, all values found will be included in output. Default is None. adaptive_index_dtype : bool, optional If ``True``, instead of returning the default CuPy signed integer dtype, the smallest signed integer dtype capable of representing the image coordinate range will be used. This can substantially reduce memory usage and slightly reduce runtime. Note that this optional parameter is not available in the SciPy API. Returns ------- indices : dictionary A Python dictionary of array indices for each distinct value. The dictionary is keyed by the distinct values, the entries are array index tuples covering all occurrences of the value within the array. This dictionary can occupy significant memory, often several times the size of the input array. To help reduce memory overhead, the argument `adaptive_index_dtype` can be set to ``True``. Notes ----- For a small array with few distinct values, one might use `numpy.unique()` to find all possible values, and ``(arr == val)`` to locate each value within that array. However, for large arrays, with many distinct values, this can become extremely inefficient, as locating each value would require a new search through the entire array. Using this function, there is essentially one search, with the indices saved for all distinct values. This is useful when matching a categorical image (e.g. a segmentation or classification) to an associated image of other data, allowing any per-class statistic(s) to then be calculated. Provides a more flexible alternative to functions like ``scipy.ndimage.mean()`` and ``scipy.ndimage.variance()``. Some other closely related functionality, with different strengths and weaknesses, can also be found in ``scipy.stats.binned_statistic()`` and the `scikit-image `_ function ``skimage.measure.regionprops()``. Note for IDL users: this provides functionality equivalent to IDL's REVERSE_INDICES option (as per the IDL documentation for the `HISTOGRAM `_ function). .. versionadded:: 1.10.0 See Also -------- label, maximum, median, minimum_position, extrema, sum, mean, variance, standard_deviation, cupy.where, cupy.unique Examples -------- >>> import cupy >>> from cupyx.scipy import ndimage >>> a = cupy.zeros((6, 6), dtype=int) >>> a[2:4, 2:4] = 1 >>> a[4, 4] = 1 >>> a[:2, :3] = 2 >>> a[0, 5] = 3 >>> a array([[2, 2, 2, 0, 0, 3], [2, 2, 2, 0, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0]]) >>> val_indices = ndimage.value_indices(a) The dictionary `val_indices` will have an entry for each distinct value in the input array. >>> val_indices.keys() dict_keys([0, 1, 2, 3]) The entry for each value is an index tuple, locating the elements with that value. >>> ndx1 = val_indices[1] >>> ndx1 (array([2, 2, 3, 3, 4]), array([2, 3, 2, 3, 4])) This can be used to index into the original array, or any other array with the same shape. >>> a[ndx1] array([1, 1, 1, 1, 1]) If the zeros were to be ignored, then the resulting dictionary would no longer have an entry for zero. >>> val_indices = ndimage.value_indices(a, ignore_value=0) >>> val_indices.keys() dict_keys([1, 2, 3]) iuz(Parameter 'arr' must be an integer arrayrrcNrdFrc3FK|]}|dVdS)FrN)r)r6ccoord_int_types r(rz value_indices..Ws3LLqxxUx;;LLLLLLr*rc32K|]}|zVdSrr5)r6r\rOrJs r(rz value_indices..bs1DD1VFUN23DDDDDDr*)r rrr min_scalar_typerFrrrrfbincountrGr unravel_indexrgr enumerate) arrrWrXraveled_int_typearr1dcountsisortcoordsr{valuer]rOrJs @@@r( value_indicesrjsZ y~T!!EFFFE /#ch--!2C0DEE-CI0B.CDD KKOOE ]5 ! !F LT * * *E; -E ::  sy 1 1FMLLLLVLLLLL F C \& ! !F!&)) u A::  l " " eOF DDDDDVDDDDDE % Jr*)NN)r`)r`F)FF)NNFFFFF)F)(rrr rrr)rrrCrDrErGrHrTrrrnryrvr|rrrhrrrrrrrrrrrrr#r1rOrRrjr5r*r(rksX D D D D N""",*** (-(-(-V + + +,,,....352C# $ $.e-1  /u.1'   =>(-        I1I1I1I1X=F=F=F=F@,,,,2@A@A@A@AF5555(      DFK9>\\\\~;;;;8;;;;8>>>>86J6J6J6Jr6J6J6J6Jr=<=<=<=<@$5$5$5$5PDIAAAAHD(,%JJJJJJJr*