9iSSKrSSKJr SSKJrJrJr SSK J r SSK J r SSK JrJrJrJrJrJrJr \\\4rS rSS jr\"5SSS .S jj5rSS jrSSjrSrSSjrSr\R<4SjrSr S Sjr!Sr"Sr#\"5S!SSSSS.Sjj5r$Sr%S"SS .Sjjr&g)#N)ndimage)SimilarityTransformAffineTransformProjectiveTransform) _warp_fast) block_reduce)get_bound_method_class safe_as_intwarnconvert_to_float_to_ndimage_mode_validate_interpolation_orderchannel_as_last_axiscF[U5n[U5nURnX R:a-USX R- -- n[R "X5nX4$X RS- :XaXRS4-nX4$X R:a [ S5eX4$)aValidate resize output shape according to input image. Parameters ---------- image: ndarray Image to be resized. output_shape: iterable Size of the generated output image `(rows, cols[, ...][, dim])`. If `dim` is not provided, the number of channels is preserved. Returns ------- image: ndarray The input image, but with additional singleton dimensions appended in the case where ``len(output_shape) > input.ndim``. output_shape: tuple The output image converted to tuple. Raises ------ ValueError: If output_shape length is smaller than the image number of dimensions Notes ----- The input image is reshaped if its number of dimensions is not equal to output_shape_length. )rrzIoutput_shape length cannot be smaller than the image number of dimensions)tuplelenshapendimnpreshape ValueError)image output_shape output_ndim input_shapes X/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/skimage/transform/_warps.py_preprocess_resize_output_shaper s>&Ll#K++KZZt{ZZ788  5.    Q &#{{2&88    zz ! )   c H[X5upURn URn U [R:XaUR [R 5nUciU [:X+=(aX [R"U [R5=(a US:H(+=(a [S[X555nU [:XaU(a [S5e[R"X5n [X5nUS:a [X5n[!U5n U(aUc[R""SU S- S- 5nO[R$"U5[R&"U 5-n[R"US:5(a [S5e[R"US:U S:*-5(a [)S5 [*R,"XXLS9n OUn U Vs/sHnSU- PM nn[*R."XX,US S 9n[1UUX4U5 U$s snf) a Resize image to match a certain size. Performs interpolation to up-size or down-size N-dimensional images. Note that anti-aliasing should be enabled when down-sizing images to avoid aliasing artifacts. For downsampling with an integer factor also see `skimage.transform.downscale_local_mean`. Parameters ---------- image : ndarray Input image. output_shape : iterable Size of the generated output image `(rows, cols[, ...][, dim])`. If `dim` is not provided, the number of channels is preserved. In case the number of input channels does not equal the number of output channels a n-dimensional interpolation is applied. Returns ------- resized : ndarray Resized version of the input. Other parameters ---------------- order : int, optional The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See `skimage.transform.warp` for detail. mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of `numpy.pad`. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool, optional Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html anti_aliasing : bool, optional Whether to apply a Gaussian filter to smooth the image prior to downsampling. It is crucial to filter when downsampling the image to avoid aliasing artifacts. If not specified, it is set to True when downsampling an image whose data type is not bool. It is also set to False when using nearest neighbor interpolation (``order`` == 0) with integer input data type. anti_aliasing_sigma : {float, tuple of floats}, optional Standard deviation for Gaussian filtering used when anti-aliasing. By default, this value is chosen as (s - 1) / 2 where s is the downsampling factor, where s > 1. For the up-size case, s < 1, no anti-aliasing is performed prior to rescaling. Notes ----- Modes 'reflect' and 'symmetric' are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values [0, 1, 2] and was padded to the right by four values using symmetric, the result would be [0, 1, 2, 2, 1, 0, 0], while for reflect it would be [0, 1, 2, 1, 0, 1, 2]. Examples -------- >>> from skimage import data >>> from skimage.transform import resize >>> image = data.camera() >>> resize(image, (100, 100)).shape (100, 100) rc3.# UH upX:v M g7fN).0xys r resize..sE&DdaAE&Dsz.anti_aliasing must be False for boolean imagesrr zFAnti-aliasing standard deviation must be greater than or equal to zerozWAnti-aliasing standard deviation greater than zero but not down-sampling along all axes)cvalmodeT)orderr,r+ grid_mode)r rdtyperfloat16astypefloat32bool issubdtypeintegeranyziprdividerrrmaximum atleast_1d ones_liker ndigaussian_filterzoom_clip_warp_output)rrr-r,r+clippreserve_range anti_aliasinganti_aliasing_sigmar input_typefactorsndi_modefilteredf zoom_factorsouts rresizerKGsh:%NE++KJRZZ RZZ(d " F]]:rzz:IuzJ FEc,&DEE  TmIJJii 2G )* >> from skimage import data >>> from skimage.transform import rescale >>> image = data.camera() >>> rescale(image, 0.1).shape (51, 51) >>> rescale(image, 0.5).shape (256, 256) Nrz4Supply a single scale, or one value per spatial axisr)r-r,r+r@rArBrC) rr:rrr concatenateasarrayrr9roundrK) rscaler-r,r+r@rArBrCrL multichannel orig_shapers rrescalerTsv MM% Et+L 5zA~Uuzz!9 SZ5::>9VW W NNEA3<0EEKK(J::bhhu'9:A>L%b> R     %#/  r!c URSURSpUR[R:XaUR [R 5nUc[R "X45S- S- nO[R"U5n[US9n [[R"U5S9n [U*S9n X-U -nSnU(a[R "SS/SU S- /U S- U S- /U S- S//5nURU5nUSS2S4R5nUSS2S4R5nUSS2S4R5nUSS2S4R5nUU- S-nUU- S-n[R"UU45nUU4n[US9nUU-nSURS '[UUUUUUUUS 9$) a Rotate image by a certain angle around its center. Parameters ---------- image : ndarray Input image. angle : float Rotation angle in degrees in counter-clockwise direction. resize : bool, optional Determine whether the shape of the output image will be automatically calculated, so the complete rotated image exactly fits. Default is False. center : iterable of length 2 The rotation center. If ``center=None``, the image is rotated around its center, i.e. ``center=(cols / 2 - 0.5, rows / 2 - 0.5)``. Please note that this parameter is (cols, rows), contrary to normal skimage ordering. Returns ------- rotated : ndarray Rotated version of the input. Other parameters ---------------- order : int, optional The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See `skimage.transform.warp` for detail. mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of `numpy.pad`. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool, optional Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html Notes ----- Modes 'reflect' and 'symmetric' are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values [0, 1, 2] and was padded to the right by four values using symmetric, the result would be [0, 1, 2, 2, 1, 0, 0], while for reflect it would be [0, 1, 2, 1, 0, 1, 2]. Examples -------- >>> from skimage import data >>> from skimage.transform import rotate >>> image = data.camera() >>> rotate(image, 2).shape (512, 512) >>> rotate(image, 2, resize=True).shape (530, 530) >>> rotate(image, 90, resize=True).shape (512, 512) rrNg@?) translation)rotation)rrrr )rr-r,r+r@rA)rr/rr0r1r2arrayrOrdeg2radinverseminmaxaroundparamswarp)ranglerKcenterr-r,r+r@rArowscolstform1tform2tform3tformrcornersmincminrmaxcmaxrout_rowsout_colsrWtform4s rrotaterqJs\QQ$ {{bjj  RZZ(~4,'#-3F# V 4F "**U*; >> a = np.arange(15).reshape(3, 5) >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) >>> downscale_local_mean(a, (2, 3)) array([[3.5, 4. ], [5.5, 4.5]]) )r rmean)rrEr+r@s rdownscale_local_meanrtsX  66r!cURupVUupx[R"XW- S-Xh- S--5n US- [R"S5-nX#[R"U *U- 5--[R "Xh- XW- 5-n Xy[R "U 5--US'X[R"U 5--US'U$)Nr ).r).r)Trsqrtlogexparctan2cossin) xyrbrXstrengthradiusr'r(x0y0rhothetas r_swirl_mappingrs 44DA FB ''16a-16a-/ 0CaZ"&&) #F "&&#"77 7"**QVQV:T TEBFF5M))BvJBFF5M))BvJ Ir!c Uc,[R"UR5SSSSS2S- nUUUUS.n [U[U UUUUU U S9 $)aPerform a swirl transformation. Parameters ---------- image : ndarray Input image. center : (column, row) tuple or (2,) ndarray, optional Center coordinate of transformation. strength : float, optional The amount of swirling applied. radius : float, optional The extent of the swirl in pixels. The effect dies out rapidly beyond `radius`. rotation : float, optional Additional rotation applied to the image. Returns ------- swirled : ndarray Swirled version of the input. Other parameters ---------------- output_shape : tuple (rows, cols), optional Shape of the output image generated. By default the shape of the input image is preserved. order : int, optional The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See `skimage.transform.warp` for detail. mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode, with 'reflect' used as the default. Modes match the behaviour of `numpy.pad`. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool, optional Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html Nr r)rbrXrr)map_argsrr-r,r+r@rA)rrYrr`r) rrbrrrXrr-r,r+r@rA warp_argss rswirlrspz~%++&r*4R4014 I  !   %  r!chURS:XaUSS2SS2[R4USS&gXSS&g)a Copy b into each color layer of a, such that:: a[:,:,0] = a[:,:,1] = ... = b Parameters ---------- a : (M, N) or (M, N, P) ndarray Target array. b : (M, N) Source array. Notes ----- Color images are stored as an ``(M, N, 3)`` or ``(M, N, 4)`` arrays. N)rrnewaxis)abs r _stackcopyr\s/" vv{Arzz!"!!r!c[U5nUSUSpC[U5X4/n[U5S:XaURUS5 [R"XRS9n[R "XC4US9R SS5RnU"U5nURR SXC45RSS5n[USUS5 [USUS5 [U5S:Xa[US5US 'U$) aQBuild the source coordinates for the output of a 2-D image warp. Parameters ---------- coord_map : callable like GeometricTransform.inverse Return input coordinates for given output coordinates. Coordinates are in the shape (P, 2), where P is the number of coordinates and each element is a ``(row, col)`` pair. shape : tuple Shape of output image ``(rows, cols[, bands])``. dtype : np.dtype or string dtype for return value (sane choices: float32 or float64). Returns ------- coords : (ndim, rows, cols[, bands]) array of dtype `dtype` Coordinates for `scipy.ndimage.map_coordinates`, that will yield an image of shape (orows, ocols, bands) by drawing from source points according to the `coord_transform_fn`. Notes ----- This is a lower-level routine that produces the source coordinates for 2-D images used by `warp()`. It is provided separately from `warp` to give additional flexibility to users who would like, for example, to re-use a particular coordinate mapping, to use specific dtypes at various points along the the image-warping process, or to implement different post-processing logic than `warp` performs after the call to `ndi.map_coordinates`. Examples -------- Produce a coordinate map that shifts an image up and to the right: >>> from skimage import data >>> from scipy.ndimage import map_coordinates >>> >>> def shift_up10_left20(xy): ... return xy - np.array([-20, 10])[None, :] >>> >>> image = data.astronaut().astype(np.float32) >>> coords = warp_coords(shift_up10_left20, image.shape) >>> warped_image = map_coordinates(image, coords) rrrr r/r)r.)r.)r .) r rappendremptyindicesrrwswapaxesrrange) coord_maprr/rcrd coords_shapecoords tf_coordss r warp_coordsrssb  Eq58$J+L 5zQE!H% XXl 0F D>q!DIvf~y01vf~y01 5zQuQxv Mr!cU(GaH[R"U5n[R"U5(a)[Rn[RnU"U5nO [Rn[R nU"U5nUS:H=(aA XSs=:*=(a U:*Os (+=(a! U"U5Us=:*=(a U"U5:*Os n U (a1UR RU5n[XS5n[ X5n[R"U5[R"U5p[R"XXS9 gg)aDClip output image to range of values of input image. Note that this function modifies the values of `output_image` in-place and it is only modified if ``clip=True``. Parameters ---------- input_image : ndarray Input image. output_image : ndarray Output image, which is modified in-place. Other parameters ---------------- mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'} Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of `numpy.pad`. cval : float Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. constant)rJN) rr\isnannanminnanmaxr]r/typerOr@) input_image output_imager,r+r@min_valmin_funcmax_funcmax_val preserve_cvals rr?r?s6 &&% 88G  yyHyyH{+GvvHvvH;' J  I..w.. I&$HH(<2HH  $$))$/D'(G'(G::g. 70C  wA; r!c ^^Tc0mURS:Xa[SUR5e[URU5nUS:aH[ X5nUR[ R:XaUR[ R5n[ R"UR5n UcU nO [U5nSn US:Xa [S5 US;GaT(GdSn [T[ R5(aTRS:XaTn O[T[5(a TR n Og[#TS5(aVTR$S :XaF['T5[;a3[ R(R+TR,R 5n U bU RUR5n UR[ R:XaS OS n UR.S:Xa[0U "UU UUUUS 9n OmUR.S :Xa]/n [3URS5H)nU R5[0U "USU4U UUUUS 95 M+ [ R6"U 5n U c[T[ R5(aTRS:Xa [9TS9m[T[ R5(aTnOjUR.S:dUR.S :a [S5eUU4Sjn[;U 5S :Xa[;U5S:XaUSUSU S4n[=UU5nUS:n[?U5n[@RB"XUUXFS9n [EX XVU5 U $)a+Warp an image according to a given coordinate transformation. Parameters ---------- image : ndarray Input image. inverse_map : transformation object, callable ``cr = f(cr, **kwargs)``, or ndarray Inverse coordinate map, which transforms coordinates in the output images into their corresponding coordinates in the input image. There are a number of different options to define this map, depending on the dimensionality of the input image. A 2-D image can have 2 dimensions for gray-scale images, or 3 dimensions with color information. - For 2-D images, you can directly pass a transformation object, e.g. `skimage.transform.SimilarityTransform`, or its inverse. - For 2-D images, you can pass a ``(3, 3)`` homogeneous transformation matrix, e.g. `skimage.transform.SimilarityTransform.params`. - For 2-D images, a function that transforms a ``(M, 2)`` array of ``(col, row)`` coordinates in the output image to their corresponding coordinates in the input image. Extra parameters to the function can be specified through `map_args`. - For N-D images, you can directly pass an array of coordinates. The first dimension specifies the coordinates in the input image, while the subsequent dimensions determine the position in the output image. E.g. in case of 2-D images, you need to pass an array of shape ``(2, rows, cols)``, where `rows` and `cols` determine the shape of the output image, and the first dimension contains the ``(row, col)`` coordinate in the input image. See `scipy.ndimage.map_coordinates` for further documentation. Note, that a ``(3, 3)`` matrix is interpreted as a homogeneous transformation matrix, so you cannot interpolate values from a 3-D input, if the output is of shape ``(3,)``. See example section for usage. map_args : dict, optional Keyword arguments passed to `inverse_map`. output_shape : tuple (rows, cols), optional Shape of the output image generated. By default the shape of the input image is preserved. Note that, even for multi-band images, only rows and columns need to be specified. order : int, optional The order of interpolation. The order has to be in the range 0-5: - 0: Nearest-neighbor - 1: Bi-linear (default) - 2: Bi-quadratic - 3: Bi-cubic - 4: Bi-quartic - 5: Bi-quintic Default is 0 if image.dtype is bool and 1 otherwise. mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of `numpy.pad`. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool, optional Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html Returns ------- warped : double ndarray The warped input image. Notes ----- - The input image is converted to a `double` image. - In case of a `SimilarityTransform`, `AffineTransform` and `ProjectiveTransform` and `order` in [0, 3] this function uses the underlying transformation matrix to warp the image with a much faster routine. Examples -------- >>> from skimage.transform import warp >>> from skimage import data >>> image = data.camera() The following image warps are all equal but differ substantially in execution time. The image is shifted to the bottom. Use a geometric transform to warp an image (fast): >>> from skimage.transform import SimilarityTransform >>> tform = SimilarityTransform(translation=(0, -10)) >>> warped = warp(image, tform) Use a callable (slow): >>> def shift_down(xy): ... xy[:, 1] -= 10 ... return xy >>> warped = warp(image, shift_down) Use a transformation matrix to warp an image (fast): >>> matrix = np.array([[1, 0, 0], [0, 1, -10], [0, 0, 1]]) >>> warped = warp(image, matrix) >>> from skimage.transform import ProjectiveTransform >>> warped = warp(image, ProjectiveTransform(matrix=matrix)) You can also use the inverse of a geometric transformation (fast): >>> warped = warp(image, tform.inverse) For N-D images you can pass a coordinate array, that specifies the coordinates in the input image for every element in the output image. E.g. if you want to rescale a 3-D cube, you can do: >>> cube_shape = np.array([30, 30, 30]) >>> rng = np.random.default_rng() >>> cube = rng.random(cube_shape) Setup the coordinate array, that defines the scaling: >>> scale = 0.1 >>> output_shape = (scale * cube_shape).astype(int) >>> coords0, coords1, coords2 = np.mgrid[:output_shape[0], ... :output_shape[1], :output_shape[2]] >>> coords = np.array([coords0, coords1, coords2]) Assume that the cube contains spatial data, where the first array element center is at coordinate (0.5, 0.5, 0.5) in real space, i.e. we have to account for this extra offset when scaling the image: >>> coords = (coords + 0.5) / scale - 0.5 >>> warped = warp(cube, coords) Nrz'Cannot warp empty image with dimensionsr aZBi-quadratic interpolation behavior has changed due to a bug in the implementation of scikit-image. The new version now serves as a wrapper around SciPy's interpolation functions, which itself is not verified to be a correct implementation. Until skimage's implementation is fixed, we recommend to use bi-linear or bi-cubic interpolation instead.)rr)rr__name__r[ float32_t float64_t)rr-r,r+r.)matrixz\Only 2-D images (grayscale or color) are supported, when providing a callable `inverse_map`.c>T"U0TD6$r$r%)args inverse_maprs rrwarp..coord_maps"D5H55r!r) prefilterr,r-r+)#sizerrrr/rrr0r1r2rYr r isinstancendarrayHOMOGRAPHY_TRANSFORMSr_hasattrrr linalginv__self__rrrrdstackrrrrr<map_coordinatesr?)rrrrr-r,r+r@rArwarpedrctypedimsdimrrrrFs `` rr`r`s n zzQBEKKPP )%++u =E qy 7 ;;"** $LL,E((5;;'K" "<0 F z  B  x k2:: . .;3D3D3N F  %: ; ; ''F K , ,$$ 1&{37LLYY]];#7#7#>#>?F  ]]5;;/F#(;;"**#>> from skimage import data >>> from skimage.transform import warp_polar >>> image = data.checkerboard() >>> warped = warp_polar(image) Perform a log-polar warp on a grayscale image: >>> warped = warp_polar(image, scaling='log') Perform a log-polar warp on a grayscale image while specifying center, radius, and output shape: >>> warped = warp_polar(image, (100,100), radius=100, ... output_shape=image.shape, scaling='log') Perform a log-polar warp on a color image: >>> image = data.astronaut() >>> warped = warp_polar(image, scaling='log', channel_axis=-1) Nr z@Input array must be 2-dimensional when `channel_axis=None`, got rzHInput array must be 3-dimensional when `channel_axis` is specified, got rVihrrrryz*Scaling value must be in {'linear', 'log'})rrrb)rr)rrrrYrrxintceilr rryrpir`)rrbrrrrLkwargsrRwhheightwidthrmap_funcrrrs r warp_polarrSsF t+L zzQ|((- | 5   zzQ<005 | =  ~((5;;'+a/36 ~xx $Ra(1,A1%BGGFO$ "<0 aQ(>( E 266&>)%EFFBEE "G#VLI  "+JPF Mr!c U(a3[R"SXS-US9n[R"SXS-US9nOUS- US- pv[R"[R"SUS- XcS9SSSU4S9nUS:Xa[RnOSU-U- n[R"[R"XU- XsS9SSSU4S9n[R"USS2[R 4U[R SS245n [R "USS 2[R 4U[R SS 245n [R "X- S5n XRSS S 9-n U $) akCreate a 2D weight matrix for resizing with the local mean. Parameters ---------- old_size: int Old size. new_size: int New size. grid_mode : bool Whether to use grid data model of pixel/voxel model for average weights computation. dtype: dtype Output array data type. Returns ------- weights: (new_size, old_size) array Rows sum to 1. rr)numr/rVrr)constant_valuesNrT)axiskeepdims)rlinspacepadinfminimumrr9sum) old_sizenew_sizer.r/ old_breaks new_breaksoldnewvalupperlowerweightss r_local_mean_weightsrsK*[[HQ,eL [[HQ,eL a<ASVV KKS3Y 9 H  !8&&C)c/CVV KK3Y 9 H   JJz!"bjj.1:bjj!"n3M NE JJz#2#rzz/2Jrzz3B34O PEjj*G {{D{11G Nr!cUbX@R*:dX@R:a [S5e[R"XS5nURSn[ U5nX`RS- :XaX4-nOJX`R:Xa0XU:wa [S5eX@R-nUSUXS-U4-nO [S5eUnO [ X5upq[Xs5nURn[[URU55HNun upX:XaM[XX(5n [R"X|U /S//5n [R"U SU 5nMP Ub[R"USU5nU$)a( Resize an array with the local mean / bilinear scaling. Parameters ---------- image : ndarray Input image. If this is a multichannel image, the axis corresponding to channels should be specified using `channel_axis`. output_shape : iterable Size of the generated output image. When `channel_axis` is not None, the `channel_axis` should either be omitted from `output_shape` or the ``output_shape[channel_axis]`` must match ``image.shape[channel_axis]``. If the length of `output_shape` exceeds image.ndim, additional singleton dimensions will be appended to the input ``image`` as needed. grid_mode : bool, optional Defines ``image`` pixels position: if True, pixels are assumed to be at grid intersections, otherwise at cell centers. As a consequence, 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. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html Returns ------- resized : ndarray Resized version of the input. See Also -------- resize, downscale_local_mean Notes ----- This method is sometimes referred to as "area-based" interpolation or "pixel mixing" interpolation [1]_. When `grid_mode` is True, it is equivalent to using OpenCV's resize with `INTER_AREA` interpolation mode. It is commonly used for image downsizing. If the downsizing factors are integers, then `downscale_local_mean` should be preferred instead. References ---------- .. [1] http://entropymine.com/imageworsener/pixelmixing/ Examples -------- >>> from skimage import data >>> from skimage.transform import resize_local_mean >>> image = data.camera() >>> resize_local_mean(image, (100, 100)).shape (100, 100) Nzinvalid channel_axisrrzWCannot reshape along the channel_axis. Use channel_axis=None to reshape along all axes.zZlen(output_shape) must be image.ndim or (image.ndim - 1) when a channel_axis is specified.) rrrmoveaxisrrr rr/ enumerater7r tensordot)rrr.rArLncrresizedr/rrrrproducts rresize_local_meanrsJ ::+ %)C34 4 E4 [[_,' **q. ('%/L JJ &)R/ C (**4L]l+l=.IIREQ 4  ? Tw7G MME&/EKK0N&O""x   %h)K,,w4&2$@++gr40 'P++gr<8 Nr!)NreflectrTFNN)FNNrrTF)rT) NrdrNNrrTF)NNNrgTFr$)TF)'numpyrscipyrr< _geometricrrr _warps_cyrmeasurer _shared.utilsr r r rrrrrr rKrTrqrtrrrfloat64rr?r`rrrrrr%r!rrsw QQ!"-o?RS/j   JZ   rrrp     {|,7^&       Qh.)+ K\8B|   Vr>> o  ood1j9>rOSrr!