144 lines
3.2 KiB
Groff
144 lines
3.2 KiB
Groff
.TH CONVOLUTION 3 "2 May 1991"
|
|
.SH NAME
|
|
im_conv, im_conv_raw, im_convf, im_convf_raw,
|
|
im_convsep, im_convsep_raw, im_convsepf, im_convsepf_raw,
|
|
im_convsub \- convolves an image with a generalised mask
|
|
.SH SYNOPSIS
|
|
#include <vips/vips.h>
|
|
|
|
int im_conv(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
INTMASK *mask;
|
|
|
|
int im_conv_raw(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
INTMASK *mask;
|
|
|
|
int im_convf(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
DOUBLEMASK *mask;
|
|
|
|
int im_convf_raw(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
DOUBLEMASK *mask;
|
|
|
|
int im_convsep(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
INTMASK *mask;
|
|
|
|
int im_convsep_raw(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
INTMASK *mask;
|
|
|
|
int im_convsepf(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
DOUBLEMASK *mask;
|
|
|
|
int im_convsepf_raw(in, out, mask)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
DOUBLEMASK *mask;
|
|
|
|
int im_convsub(in, out, mask, xskip, yskip)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
INTMASK *mask;
|
|
.br
|
|
int xskip, yskip;
|
|
|
|
int im_shrink(in, out, xfactor, yfactor)
|
|
.br
|
|
IMAGE *in, *out;
|
|
.br
|
|
double xfactor, yfactor;
|
|
|
|
.SH DESCRIPTION
|
|
These functions
|
|
convolve the image
|
|
.B in
|
|
with the matrix
|
|
.B mask
|
|
and put the result in the image
|
|
.B out.
|
|
|
|
Input should be non-complex. The size and type of the output image are
|
|
the same as the size of the input. To output a larger type (for example,
|
|
to output an int image from convolution of a byte image, avoiding clipping),
|
|
cast the input image up with
|
|
.B im_clip2fmt(3).
|
|
|
|
The output image is the same size as the input. The edge pixels are calculated
|
|
by expanding the input image using
|
|
.B im_embed(3)
|
|
in mode 1 (replicating edge pixels) just enough so that the output can match
|
|
the input.
|
|
|
|
The output at each point is divided by scale and then the offset is added.
|
|
Both offset and scale are held in mask.
|
|
|
|
The
|
|
.B im_conv*(3)
|
|
functions have 'raw' versions which do not add the border: instead the
|
|
output image is smaller than the input.
|
|
|
|
.B im_conv(3)
|
|
and
|
|
.B im_conv_raw(3)
|
|
convolve any non-complex input image to make an output image of the same
|
|
type. Rounding is appropriate to the image type.
|
|
|
|
.B im_convf(3)
|
|
and
|
|
.B im_convf_raw(3)
|
|
convolves to float (double if the input is double).
|
|
The function expects a double mask.
|
|
|
|
.B im_convsep(3)
|
|
and
|
|
.B im_convsep_raw(3)
|
|
carry out convolution using an 1xN or Nx1 separable mask.
|
|
|
|
The function scales the output result by dividing it with scale*scale. The
|
|
scale factor should therefore be the sqrt of the scale of the square NxN mask.
|
|
|
|
Rounding is appropriate to the image type. It works on any non-complex image,
|
|
and writes the output in the same format as the input.
|
|
The function expects integer mask.
|
|
|
|
.B im_convsepf(3)
|
|
and
|
|
.B im_convsepf_raw(3)
|
|
convolves to float (double if the input is double).
|
|
The function expects a double mask.
|
|
|
|
.B im_convsub(3)
|
|
convolves the byte image pointed by in and writes the result as a byte output.
|
|
Using this function the input image is subsampled on
|
|
both directions by an integer factor of xskip horizontally and
|
|
an integer factor of yskip vertically.
|
|
During the covolution, values are rounded before division.
|
|
Both input and output are bytes. Output is clipped between 0 and 255.
|
|
The function expects an integer mask.
|
|
|
|
.SH RETURN VALUE
|
|
The functions returns 0 on success and -1 on error.
|
|
.SH SEE ALSO
|
|
im_read_imask(3), im_compass(3), im_fastcor(3), im_log_dmask(3),
|
|
im_clip2fmt(3)
|