Resize image

`B = imresize(A, scale)`

gpuarrayB = imresize(gpuarrayA,scale)

B = imresize(A, [numrows numcols])

[Y newmap] = imresize(X, map, scale)

[...] = imresize(...,* method*)

[...] = imresize(...,

`parameter`

`value`

`B = imresize(A, scale)`

returns
image `B`

that is `scale`

times
the size of `A`

. The input image `A`

can
be a grayscale, RGB, or binary image. If `scale`

is
between 0 and 1.0, `B`

is smaller than `A`

.
If `scale`

is greater than 1.0, `B`

is
larger than `A`

. By default, `imresize`

uses
bicubic interpolation.

`gpuarrayB = imresize(gpuarrayA,scale)`

performs
the resize operation on a GPU. The input image and the output image
are gpuArrays. When used with gpuArrays, `imresize`

only
supports cubic interpolation and always performs antialiasing. This
syntax requires the Parallel Computing Toolbox™.

`B = imresize(A, [numrows numcols])`

returns
image `B`

that has the number of rows and columns
specified by `[numrows numcols]`

. Either `numrows`

or `numcols`

may
be `NaN`

, in which case `imresize`

computes
the number of rows or columns automatically to preserve the image
aspect ratio.

`[Y newmap] = imresize(X, map, scale)`

resizes
the indexed image `X`

. `scale`

can
either be a numeric scale factor or a vector that specifies the size
of the output image (`[numrows numcols]`

). By default, `imresize`

returns
a new, optimized colormap (`newmap`

) with the resized
image. To return a colormap that is the same as the original colormap,
use the `'Colormap'`

parameter (see below).

`[...] = imresize(...,`

specifies
the interpolation method used. * method*)

`method`

`{f,w}`

, that specifies an
interpolation kernel, where `f`

is a function handle
for a custom interpolation kernel and `w`

is the
custom kernel's width.`f`

may be called with a scalar or a vector
input..Method | Description |
---|---|

| Nearest-neighbor interpolation; the output pixel is assigned the value of the pixel that the point falls within. No other pixels are considered. |

| Bilinear interpolation; the output pixel value is a weighted average of pixels in the nearest 2-by-2 neighborhood |

| Bicubic interpolation (the default); the output pixel value is a weighted average of pixels in the nearest 4-by-4 neighborhood |

`'box'` | Box-shaped kernel |

`'triangle'` | Triangular kernel (equivalent to `'bilinear'` ) |

`'cubic'` | Cubic kernel (equivalent to `'bicubic'` ) |

`'lanczos2'` | Lanczos-2 kernel |

`'lanczos3'` | Lanczos-3 kernel |

`[...] = imresize(..., `

you can control various aspects of the resizing operation
by specifying parameter/value pairs with any of the previous syntaxes.
The following table lists these parameters.* parameter*,

`value`

Parameter | Value |
---|---|

`'Antialiasing'` | A Boolean value that specifies whether to perform antialiasing
when shrinking an image. The default value depends on the interpolation
method. If the method is nearest-neighbor (`'nearest'` ),
the default is `false` ; for all other interpolation
methods, the default is `true` . |

'`Colormap'` | A text string that specifies whether `imresize` returns
an optimized colormap or the original colormap (Indexed images only).
If set to `'original'` , the output colormap (`newmap` )
is the same as the input colormap (`map` ). If set
to `'optimized'` , `imresize` returns
a new optimized colormap. The default value is `'optimized'` . |

`'Dither'` | A Boolean value that specifies whether to perform color dithering
(Indexed images only). The default value is `true` . |

`'Method'` | As described above |

`'OutputSize'` | A two-element vector, `[numrows numcols]` ,
that specifies the size of the output image. If you specify `NaN` for
one of the values, `imresize` computes the value
of the dimension to preserve the aspect ratio of the original image. |

`'Scale'` | A scalar or two-element vector that specifies the resize scale
factors. If you specify a scalar, `imresize` uses
the value as the scale factor for each dimension. If you specify a
vector, `imresize` uses the individual values as
the scale factors for the row and column dimensions, respectively. |

The input image can be numeric or logical and it must be nonsparse.
The output image is of the same class as the input image. An input
image that is an indexed image can be `uint8`

, `uint16`

,
or `double`

.

The input image `gpuarrayA`

can be can be a
single- or double-precision gpuArray. The output gpuArray image is
of the same underlying class as the input image.

Shrink image by factor of two, using default interpolation and antialiasing.

I = imread('rice.png'); J = imresize(I, 0.5); figure, imshow(I), figure, imshow(J)

Shrink image by factor of two, performing the operation on a GPU.

I = im2double(gpuArray(imread('rice.png'))); J = imresize(I, 0.5); figure, imshow(I), figure, imshow(J)

Shrink by factor of two using nearest-neighbor interpolation. This is the fastest method, but it has the lowest quality.

J2 = imresize(I, 0.5, 'nearest');

Resize an indexed image

[X, map] = imread('trees.tif'); [Y, newmap] = imresize(X, map, 0.5); imshow(Y, newmap)

Resize an RGB image to have 64 rows. Let `imresize`

calculate
the number of columns necessary to preserve the aspect ratio.

RGB = imread('peppers.png'); RGB2 = imresize(RGB, [64 NaN]);

Resize an RGB image, performing the operation on a GPU.

RGB = gpuArray(im2single(imread('peppers.png'))); RGB2 = imresize(RGB, 2);

`gpuArray`

| `imrotate`

| `imtransform`

| `interp2`

| `tformarray`

Was this topic helpful?