## resample

resample

## Functions

int | vips_shrink ()
int | vips_shrinkh ()
int | vips_shrinkv ()
int | vips_shrink2 ()
int | vips_similarity ()
int | vips_affine ()
int | vips_resize ()
int | vips_mapim ()
int | vips_quadratic ()

## Description

## Functions

### vips_shrink ()

    int
    vips_shrink (VipsImage *in,
                 VipsImage **out,
                 double xshrink,
                 double yshrink,
                 ...);

Shrink `in` by a pair of factors with a simple box filter. For non-integer factors, `vips_shrink()` will first shrink by the integer part with a box filter, then use `vips_affine()` plus bilinear interpolation to shrink by the remaining fractional part.

This is a very low-level operation: see `vips_resize()` for a more convenient way to resize images.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See also: `vips_resize()`, `vips_affine()`.

#### Parameters

in | input image |
out | output image |
xshrink | horizontal shrink |
yshrink | vertical shrink |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_shrinkh ()

    int
    vips_shrinkh (VipsImage *in,
                  VipsImage **out,
                  int xshrink,
                  ...);

Shrink `in` horizontally by an integer factor. Each pixel in the output is the average of the corresponding line of `xshrink` pixels in the input.

This is a very low-level operation: see `vips_resize()` for a more convenient way to resize images.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See also: `vips_shrinkv()`, `vips_shrink()`, `vips_resize()`, `vips_affine()`.

#### Parameters

in | input image |
out | output image |
xshrink | horizontal shrink |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_shrinkv ()

    int
    vips_shrinkv (VipsImage *in,
                  VipsImage **out,
                  int yshrink,
                  ...);

Shrink `in` vertically by an integer factor. Each pixel in the output is the average of the corresponding column of `yshrink` pixels in the input.

You will get aliasing for non-integer shrinks. In this case, shrink with this function to the nearest integer size above the target shrink, then downsample to the exact size with `vips_affine()` and your choice of interpolator. See `vips_resize()` for a convenient way to do this.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See also: `vips_shrinkh()`, `vips_shrink()`, `vips_resize()`, `vips_affine()`.

#### Parameters

in | input image |
out | output image |
yshrink | vertical shrink |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_shrink2 ()

    int
    vips_shrink2 (VipsImage *in,
                  VipsImage **out,
                  double xshrink,
                  double yshrink,
                  ...);

Shrink `in` by a pair of factors with a simple box filter.

This is an old version of `vips_shrink()` kept around for testing. Use `vips_shrink()` in preference.

See also: `vips_resize()`, `vips_affine()`.

#### Parameters

in | input image |
out | output image |
xshrink | horizontal shrink |
yshrink | vertical shrink |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_similarity ()

    int
    vips_similarity (VipsImage *in,
                     VipsImage **out,
                     ...);

Optional arguments:

`scale` : scale by this factor `angle` : rotate by this many degrees anticlockwise `interpolate` : interpolate pixels with this `idx` : input horizontal offset `idy` : input vertical offset `odx` : output horizontal offset `ody` : output vertical offset

This operator calls `vips_affine()` for you, calculating the matrix for the affine transform from `scale` and `angle` . Other parameters are passed on to `vips_affine()` unaltered.

See also: `vips_affine()`, VipsInterpolate.

#### Parameters

in | input image |
out | output image |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_affine ()

    int
    vips_affine (VipsImage *in,
                 VipsImage **out,
                 double a,
                 double b,
                 double c,
                 double d,
                 ...);

Optional arguments:

`interpolate` : interpolate pixels with this `oarea` : output rectangle `idx` : input horizontal offset `idy` : input vertical offset `odx` : output horizontal offset `ody` : output vertical offset

This operator performs an affine transform on an image using `interpolate` .

The transform is:

X = `a` * (x + `idx` ) + `b` * (y + `idy` ) + `odx` Y = `c` * (x + `idx` ) + `d` * (y + `idy` ) + `doy`

x and y are the coordinates in input image. X and Y are the coordinates in output image. (0,0) is the upper left corner.

The section of the output space defined by `oarea` is written to `out` . `oarea` is a four-element int array of left, top, width, height. By default `oarea` is just large enough to cover the whole of the transformed input image.

`interpolate` defaults to bilinear.

`idx` , `idy` , `odx` , `ody` default to zero.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See also: `vips_shrink()`, `vips_resize()`, VipsInterpolate.

#### Parameters

in | input image |
out | output image |
a | transformation matrix coefficient |
b | transformation matrix coefficient |
c | transformation matrix coefficient |
d | transformation matrix coefficient |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_resize ()

    int
    vips_resize (VipsImage *in,
                 VipsImage **out,
                 double scale,
                 ...);

Optional arguments:

`vscale` : vertical scale factor `interpolate` : interpolate pixels with this `idx` : input horizontal offset `idy` : input vertical offset

Resize an image. When upsizing (`scale` > 1), the image is simply resized with `vips_affine()` and the supplied `interpolate` . When downsizing, the image is block-shrunk with `vips_shrink()` to roughly half the interpolator window size above the target size, then blurred with an anti-alias filter, then resampled with `vips_affine()` and the supplied interpolator, then sharpened.

vips_resize() normally maintains the image apect ratio. If you set `vscale` , that factor is used for the vertical scale and `scale` for the horizontal.

`interpolate` defaults to bicubic.

`idx` , `idy` default to zero. Set them to 0.5 to get pixel-centre sampling.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See also: `vips_shrink()`, `vips_affine()`, VipsInterpolate.

#### Parameters

in | input image |
out | output image |
scale | scale factor |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_mapim ()

    int
    vips_mapim (VipsImage *in,
                VipsImage **out,
                VipsImage *index,
                ...);

Optional arguments:

`interpolate` : interpolate pixels with this

This operator resamples `in` using `index` to look up pixels. `out` is the same size as `index` , with each pixel being fetched from that position in `in` . That is:

    out[x, y] = in[index[x, y]]

If `index` has one band, that band must be complex. Otherwise, `index` must have two bands of any format. Coordinates in `index` are in pixels, with (0, 0) being the top-left corner of `in` , and with y increasing down the image. Use `vips_xyz()` to build index images.

`interpolate` defaults to bilinear.

This operation does not change xres or yres. The image resolution needs to be updated by the application.

See `vips_maplut()` for a 1D equivalent of this operation.

See also: `vips_xyz()`, `vips_affine()`, `vips_resize()`, `vips_maplut()`, VipsInterpolate.

#### Parameters

in | input image |
out | output image |
index | index image |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

### vips_quadratic ()

    int
    vips_quadratic (VipsImage *in,
                    VipsImage **out,
                    VipsImage *coeff,
                    ...);

Optional arguments:

`interpolate` : use this interpolator (default bilinear)

This operation is unfinished and unusable, sorry.

See also: `vips_affine()`.

#### Parameters

in | input image |
out | output image |
coeff | horizontal quadratic |
... | `NULL`-terminated list of optional named arguments |

#### Returns

0 on success, -1 on error

## Types and Values