vips_add ()

int
vips_add (VipsImage *left,
          VipsImage *right,
          VipsImage **out,
          ...);

This operation calculates in1 + in2 and writes the result to out .

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

following table is used to determine the output type:

In other words, the output type is just large enough to hold the whole range of possible values.

Operations on integer images are performed using the processor's vector unit, if possible. Disable this with --vips-novector or VIPS_NOVECTOR.

See also: vips_subtract(), vips_linear().

vips_sum ()

int
vips_sum (VipsImage **in,
          VipsImage **out,
          int n,
          ...);

This operation sums all images in in and writes the result to out .

If the images differ in size, the smaller images are enlarged to match the largest by adding zero pixels along the bottom and right.

If the number of bands differs, all but one of the images must have one band. In this case, n-band images are formed from the one-band images by joining n copies of the one-band images together, and then the n-band images are operated upon.

The input images are cast up to the smallest common format (see table Smallest common format in

following table is used to determine the output type:

In other words, the output type is just large enough to hold the whole range of possible values.

See also: vips_add().

vips_subtract ()

int
vips_subtract (VipsImage *in1,
               VipsImage *in2,
               VipsImage **out,
               ...);

This operation calculates in1 - in2 and writes the result to out .

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

following table is used to determine the output type:

In other words, the output type is just large enough to hold the whole range of possible values.

See also: vips_add(), vips_linear().

vips_multiply ()

int
vips_multiply (VipsImage *left,
               VipsImage *right,
               VipsImage **out,
               ...);

This operation calculates left * right and writes the result to out .

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

following table is used to determine the output type:

In other words, the output type is just large enough to hold the whole range of possible values.

See also: vips_add(), vips_linear().

vips_divide ()

int
vips_divide (VipsImage *left,
             VipsImage *right,
             VipsImage **out,
             ...);

This operation calculates in1 / in2 and writes the result to out . If any pixels in in2 are zero, the corresponding pixel in out is also zero.

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

following table is used to determine the output type:

In other words, the output type is just large enough to hold the whole range of possible values.

See also: vips_multiply(), vips_linear(), vips_pow().

vips_linear ()

int
vips_linear (VipsImage *in,
             VipsImage **out,
             const double *a,
             const double *b,
             int n,
             ...);

Optional arguments:

Pass an image through a linear transform, ie. (out = in * a + b ). Output is float for integer input, double for double input, complex for complex input and double complex for double complex input. Set uchar to output uchar pixels.

If the arrays of constants have just one element, that constant is used for all image bands. If the arrays have more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_linear1(), vips_add().

[method]

vips_linear1 ()

int
vips_linear1 (VipsImage *in,
              VipsImage **out,
              double a,
              double b,
              ...);

Optional arguments:

Run vips_linear() with a single constant.

See also: vips_linear().

[method]

vips_remainder ()

int
vips_remainder (VipsImage *left,
                VipsImage *right,
                VipsImage **out,
                ...);

This operation calculates left % right (remainder after integer division) and writes the result to out . The images may have any non-complex format. For float formats, vips_remainder() calculates in1 - in2 * floor (in1 / in2 ).

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

result type.

See also: vips_remainder_const(), vips_divide(), vips_round().

vips_remainder_const ()

int
vips_remainder_const (VipsImage *in,
                      VipsImage **out,
                      const double *c,
                      int n,
                      ...);

This operation calculates in % c (remainder after division by an array of constants) and writes the result to out . The image may have any non-complex format. For float formats, vips_remainder_const() calculates in - c * floor (in / c ).

If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_remainder(), vips_divide(), vips_round().

[method]

vips_remainder_const1 ()

int
vips_remainder_const1 (VipsImage *in,
                       VipsImage **out,
                       double c,
                       ...);

This operation calculates in % c (remainder after division by a constant) and writes the result to out . The image may have any non-complex format. For float formats, vips_remainder_const() calculates in - c * floor (in / c ).

If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_remainder(), vips_divide(), vips_round().

[method]

vips_invert ()

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

For unsigned formats, this operation calculates (max - in ), eg. (255 - in ) for uchar. For signed and float formats, this operation calculates (-1 in ).

For complex images, only the real part is inverted. See also vips_conj().

See also: vips_linear().

[method]

vips_abs ()

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

This operation finds the absolute value of an image. It does a copy for unsigned integer types, negate for negative values in signed integer types, fabs(3) for float types, and calculates modulus for complex types.

See also: vips_sign().

[method]

vips_sign ()

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

Finds the unit vector in the direction of the pixel value. For non-complex images, it returns a signed char image with values -1, 0, and 1 for negative, zero and positive pixels. For complex images, it returns a complex normalised to length 1.

See also: vips_abs().

[method]

vips_round ()

int
vips_round (VipsImage *in,
            VipsImage **out,
            VipsOperationRound round,
            ...);

Round to an integral value.

Copy for integer types, round float and complex types.

The format of out is always the same as in , so you may wish to cast to an integer format afterwards.

See also: vips_cast()

[method]

vips_floor ()

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

Round to an integral value with VIPS_OPERATION_ROUND_FLOOR. See vips_round().

[method]

vips_ceil ()

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

Round to an integral value with VIPS_OPERATION_ROUND_CEIL. See vips_round().

[method]

vips_rint ()

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

Round to an integral value with VIPS_OPERATION_ROUND_RINT. See vips_round().

[method]

vips_math ()

int
vips_math (VipsImage *in,
           VipsImage **out,
           VipsOperationMath math,
           ...);

Perform various functions in -lm, the maths library, on images.

Angles are expressed in degrees. The output type is float unless the input is double, in which case the output is double.

Non-complex images only.

See also: vips_math2().

[method]

vips_sin ()

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

Perform VIPS_OPERATION_MATH_SIN on an image. See vips_math().

[method]

vips_cos ()

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

Perform VIPS_OPERATION_MATH_COS on an image. See vips_math().

[method]

vips_tan ()

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

Perform VIPS_OPERATION_MATH_TAN on an image. See vips_math().

[method]

vips_asin ()

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

Perform VIPS_OPERATION_MATH_ASIN on an image. See vips_math().

[method]

vips_acos ()

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

Perform VIPS_OPERATION_MATH_ACOS on an image. See vips_math().

[method]

vips_atan ()

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

Perform VIPS_OPERATION_MATH_ATAN on an image. See vips_math().

[method]

vips_exp ()

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

Perform VIPS_OPERATION_MATH_EXP on an image. See vips_math().

[method]

vips_exp10 ()

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

Perform VIPS_OPERATION_MATH_EXP10 on an image. See vips_math().

[method]

vips_log ()

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

Perform VIPS_OPERATION_MATH_LOG on an image. See vips_math().

[method]

vips_log10 ()

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

Perform VIPS_OPERATION_MATH_LOG10 on an image. See vips_math().

[method]

vips_complex ()

int
vips_complex (VipsImage *in,
              VipsImage **out,
              VipsOperationComplex cmplx,
              ...);

Perform various operations on complex images.

Angles are expressed in degrees. The output type is complex unless the input is double or dpcomplex, in which case the output is dpcomplex.

[method]

vips_polar ()

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

Perform VIPS_OPERATION_COMPLEX_POLAR on an image. See vips_complex().

[method]

vips_rect ()

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

Perform VIPS_OPERATION_COMPLEX_RECT on an image. See vips_complex().

[method]

vips_conj ()

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

Perform VIPS_OPERATION_COMPLEX_CONJ on an image. See vips_complex().

[method]

vips_complex2 ()

int
vips_complex2 (VipsImage *left,
               VipsImage *right,
               VipsImage **out,
               VipsOperationComplex2 cmplx,
               ...);

Perform various binary operations on complex images.

Angles are expressed in degrees. The output type is complex unless the input is double or dpcomplex, in which case the output is dpcomplex.

vips_cross_phase ()

int
vips_cross_phase (VipsImage *left,
                  VipsImage *right,
                  VipsImage **out,
                  ...);

Perform VIPS_OPERATION_COMPLEX2_CROSS_PHASE on an image. See vips_complex2().

vips_complexget ()

int
vips_complexget (VipsImage *in,
                 VipsImage **out,
                 VipsOperationComplexget get,
                 ...);

Get components of complex images.

The output type is the same as the input type, except VIPS_FORMAT_COMPLEX becomes VIPS_FORMAT_FLOAT and VIPS_FORMAT_DPCOMPLEX becomes VIPS_FORMAT_DOUBLE.

[method]

vips_real ()

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

Perform VIPS_OPERATION_COMPLEXGET_REAL on an image. See vips_complexget().

[method]

vips_imag ()

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

Perform VIPS_OPERATION_COMPLEXGET_IMAG on an image. See vips_complexget().

[method]

vips_complexform ()

int
vips_complexform (VipsImage *left,
                  VipsImage *right,
                  VipsImage **out,
                  ...);

Compose two real images to make a complex image. If either left or right are VIPS_FORMAT_DOUBLE, out is VIPS_FORMAT_DPCOMPLEX. Otherwise out is VIPS_FORMAT_COMPLEX. left becomes the real component of out and right the imaginary.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

See also: vips_complexget().

vips_relational ()

int
vips_relational (VipsImage *left,
                 VipsImage *right,
                 VipsImage **out,
                 VipsOperationRelational relational,
                 ...);

Perform various relational operations on pairs of images.

The output type is always uchar, with 0 for FALSE and 255 for TRUE.

Less-than and greater-than for complex images compare the modulus.

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

To decide if pixels match exactly, that is have the same value in every band, use vips_bandbool() after this operation to AND or OR image bands together.

See also: vips_boolean(), vips_bandbool(), vips_relational_const().

vips_equal ()

int
vips_equal (VipsImage *left,
            VipsImage *right,
            VipsImage **out,
            ...);

Perform VIPS_OPERATION_RELATIONAL_EQUAL on a pair of images. See vips_relational().

vips_notequal ()

int
vips_notequal (VipsImage *left,
               VipsImage *right,
               VipsImage **out,
               ...);

Perform VIPS_OPERATION_RELATIONAL_NOTEQ on a pair of images. See vips_relational().

vips_less ()

int
vips_less (VipsImage *left,
           VipsImage *right,
           VipsImage **out,
           ...);

Perform VIPS_OPERATION_RELATIONAL_LESS on a pair of images. See vips_relational().

vips_lesseq ()

int
vips_lesseq (VipsImage *left,
             VipsImage *right,
             VipsImage **out,
             ...);

Perform VIPS_OPERATION_RELATIONAL_LESSEQ on a pair of images. See vips_relational().

vips_more ()

int
vips_more (VipsImage *left,
           VipsImage *right,
           VipsImage **out,
           ...);

Perform VIPS_OPERATION_RELATIONAL_MORE on a pair of images. See vips_relational().

vips_moreeq ()

int
vips_moreeq (VipsImage *left,
             VipsImage *right,
             VipsImage **out,
             ...);

Perform VIPS_OPERATION_RELATIONAL_MOREEQ on a pair of images. See vips_relational().

vips_relational_const ()

int
vips_relational_const (VipsImage *in,
                       VipsImage **out,
                       VipsOperationRelational relational,
                       const double *c,
                       int n,
                       ...);

Perform various relational operations on an image and an array of constants.

The output type is always uchar, with 0 for FALSE and 255 for TRUE.

If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_boolean(), vips_relational().

[method]

vips_equal_const ()

int
vips_equal_const (VipsImage *in,
                  VipsImage **out,
                  const double *c,
                  int n,
                  ...);

Perform VIPS_OPERATION_RELATIONAL_EQUAL on an image and a constant. See vips_relational_const().

[method]

vips_notequal_const ()

int
vips_notequal_const (VipsImage *in,
                     VipsImage **out,
                     const double *c,
                     int n,
                     ...);

Perform VIPS_OPERATION_RELATIONAL_NOTEQ on an image and a constant. See vips_relational_const().

[method]

vips_less_const ()

int
vips_less_const (VipsImage *in,
                 VipsImage **out,
                 const double *c,
                 int n,
                 ...);

Perform VIPS_OPERATION_RELATIONAL_LESS on an image and a constant. See vips_relational_const().

[method]

vips_lesseq_const ()

int
vips_lesseq_const (VipsImage *in,
                   VipsImage **out,
                   const double *c,
                   int n,
                   ...);

Perform VIPS_OPERATION_RELATIONAL_LESSEQ on an image and a constant. See vips_relational_const().

[method]

vips_more_const ()

int
vips_more_const (VipsImage *in,
                 VipsImage **out,
                 const double *c,
                 int n,
                 ...);

Perform VIPS_OPERATION_RELATIONAL_MORE on an image and a constant. See vips_relational_const().

[method]

vips_moreeq_const ()

int
vips_moreeq_const (VipsImage *in,
                   VipsImage **out,
                   const double *c,
                   int n,
                   ...);

Perform VIPS_OPERATION_RELATIONAL_MOREEQ on an image and a constant. See vips_relational_const().

[method]

vips_relational_const1 ()

int
vips_relational_const1 (VipsImage *in,
                        VipsImage **out,
                        VipsOperationRelational relational,
                        double c,
                        ...);

Perform various relational operations on an image and a constant. See vips_relational_const().

See also: vips_boolean(), vips_relational().

[method]

vips_equal_const1 ()

int
vips_equal_const1 (VipsImage *in,
                   VipsImage **out,
                   double c,
                   ...);

Perform VIPS_OPERATION_RELATIONAL_EQUAL on an image and a constant. See vips_relational_const().

[method]

vips_notequal_const1 ()

int
vips_notequal_const1 (VipsImage *in,
                      VipsImage **out,
                      double c,
                      ...);

Perform VIPS_OPERATION_RELATIONAL_NOTEQ on an image and a constant. See vips_relational_const().

[method]

vips_less_const1 ()

int
vips_less_const1 (VipsImage *in,
                  VipsImage **out,
                  double c,
                  ...);

Perform VIPS_OPERATION_RELATIONAL_LESS on an image and a constant. See vips_relational_const().

[method]

vips_lesseq_const1 ()

int
vips_lesseq_const1 (VipsImage *in,
                    VipsImage **out,
                    double c,
                    ...);

Perform VIPS_OPERATION_RELATIONAL_LESSEQ on an image and a constant. See vips_relational_const().

[method]

vips_more_const1 ()

int
vips_more_const1 (VipsImage *in,
                  VipsImage **out,
                  double c,
                  ...);

Perform VIPS_OPERATION_RELATIONAL_MORE on an image and a constant. See vips_relational_const().

[method]

vips_moreeq_const1 ()

int
vips_moreeq_const1 (VipsImage *in,
                    VipsImage **out,
                    double c,
                    ...);

Perform VIPS_OPERATION_RELATIONAL_MOREEQ on an image and a constant. See vips_relational_const().

[method]

vips_boolean ()

int
vips_boolean (VipsImage *left,
              VipsImage *right,
              VipsImage **out,
              VipsOperationBoolean boolean,
              ...);

Perform various boolean operations on pairs of images.

The output image is the same format as the upcast input images for integer types. Float types are cast to int before processing. Complex types are not supported.

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

See also: vips_boolean_const().

vips_andimage ()

int
vips_andimage (VipsImage *left,
               VipsImage *right,
               VipsImage **out,
               ...);

Perform VIPS_OPERATION_BOOLEAN_AND on a pair of images. See vips_boolean().

vips_orimage ()

int
vips_orimage (VipsImage *left,
              VipsImage *right,
              VipsImage **out,
              ...);

Perform VIPS_OPERATION_BOOLEAN_OR on a pair of images. See vips_boolean().

vips_eorimage ()

int
vips_eorimage (VipsImage *left,
               VipsImage *right,
               VipsImage **out,
               ...);

Perform VIPS_OPERATION_BOOLEAN_EOR on a pair of images. See vips_boolean().

vips_lshift ()

int
vips_lshift (VipsImage *left,
             VipsImage *right,
             VipsImage **out,
             ...);

Perform VIPS_OPERATION_BOOLEAN_LSHIFT on a pair of images. See vips_boolean().

vips_rshift ()

int
vips_rshift (VipsImage *left,
             VipsImage *right,
             VipsImage **out,
             ...);

Perform VIPS_OPERATION_BOOLEAN_RSHIFT on a pair of images. See vips_boolean().

vips_boolean_const ()

int
vips_boolean_const (VipsImage *in,
                    VipsImage **out,
                    VipsOperationBoolean boolean,
                    const double *c,
                    int n,
                    ...);

Perform various boolean operations on an image against an array of constants.

The output type is always uchar, with 0 for FALSE and 255 for TRUE.

If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_andimage_const ()

int
vips_andimage_const (VipsImage *in,
                     VipsImage **out,
                     const double *c,
                     int n,
                     ...);

Perform VIPS_OPERATION_BOOLEAN_AND on an image and an array of constants. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_orimage_const ()

int
vips_orimage_const (VipsImage *in,
                    VipsImage **out,
                    const double *c,
                    int n,
                    ...);

Perform VIPS_OPERATION_BOOLEAN_OR on an image and an array of constants. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_eorimage_const ()

int
vips_eorimage_const (VipsImage *in,
                     VipsImage **out,
                     const double *c,
                     int n,
                     ...);

Perform VIPS_OPERATION_BOOLEAN_EOR on an image and an array of constants. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_lshift_const ()

int
vips_lshift_const (VipsImage *in,
                   VipsImage **out,
                   const double *c,
                   int n,
                   ...);

Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_rshift_const ()

int
vips_rshift_const (VipsImage *in,
                   VipsImage **out,
                   const double *c,
                   int n,
                   ...);

Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and an array of constants. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const1().

[method]

vips_boolean_const1 ()

int
vips_boolean_const1 (VipsImage *in,
                     VipsImage **out,
                     VipsOperationBoolean boolean,
                     double c,
                     ...);

Perform various boolean operations on an image with a single constant. See vips_boolean_const().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_andimage_const1 ()

int
vips_andimage_const1 (VipsImage *in,
                      VipsImage **out,
                      double c,
                      ...);

Perform VIPS_OPERATION_BOOLEAN_AND on an image and a constant. See vips_boolean_const1().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_orimage_const1 ()

int
vips_orimage_const1 (VipsImage *in,
                     VipsImage **out,
                     double c,
                     ...);

Perform VIPS_OPERATION_BOOLEAN_OR on an image and a constant. See vips_boolean_const1().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_eorimage_const1 ()

int
vips_eorimage_const1 (VipsImage *in,
                      VipsImage **out,
                      double c,
                      ...);

Perform VIPS_OPERATION_BOOLEAN_EOR on an image and a constant. See vips_boolean_const1().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_lshift_const1 ()

int
vips_lshift_const1 (VipsImage *in,
                    VipsImage **out,
                    double c,
                    ...);

Perform VIPS_OPERATION_BOOLEAN_LSHIFT on an image and a constant. See vips_boolean_const1().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_rshift_const1 ()

int
vips_rshift_const1 (VipsImage *in,
                    VipsImage **out,
                    double c,
                    ...);

Perform VIPS_OPERATION_BOOLEAN_RSHIFT on an image and a constant. See vips_boolean_const1().

See also: vips_boolean(), vips_boolean_const().

[method]

vips_math2 ()

int
vips_math2 (VipsImage *left,
            VipsImage *right,
            VipsImage **out,
            VipsOperationMath2 math2,
            ...);

This operation calculates a 2-ary maths operation on a pair of images and writes the result to out . The images may have any non-complex format. out is float except in the case that either of left or right are double, in which case out is also double.

It detects division by zero, setting those pixels to zero in the output. Beware: it does this silently!

If the images differ in size, the smaller image is enlarged to match the larger by adding zero pixels along the bottom and right.

If the number of bands differs, one of the images must have one band. In this case, an n-band image is formed from the one-band image by joining n copies of the one-band image together, and then the two n-band images are operated upon.

The two input images are cast up to the smallest common format (see table Smallest common format in

result type.

See also: vips_math2_const().

vips_pow ()

int
vips_pow (VipsImage *left,
          VipsImage *right,
          VipsImage **out,
          ...);

Perform VIPS_OPERATION_MATH2_POW on a pair of images. See vips_math2().

vips_wop ()

int
vips_wop (VipsImage *left,
          VipsImage *right,
          VipsImage **out,
          ...);

Perform VIPS_OPERATION_MATH2_WOP on a pair of images. See vips_math2().

vips_math2_const ()

int
vips_math2_const (VipsImage *in,
                  VipsImage **out,
                  VipsOperationMath2 math2,
                  const double *c,
                  int n,
                  ...);

This operation calculates various 2-ary maths operations on an image and an array of constants and writes the result to out . The image may have any non-complex format. out is float except in the case that in is double, in which case out is also double.

It detects division by zero, setting those pixels to zero in the output. Beware: it does this silently!

If the array of constants has just one element, that constant is used for all image bands. If the array has more than one element and they have the same number of elements as there are bands in the image, then one array element is used for each band. If the arrays have more than one element and the image only has a single band, the result is a many-band image where each band corresponds to one array element.

See also: vips_math2(), vips_math().

[method]

vips_pow_const ()

int
vips_pow_const (VipsImage *in,
                VipsImage **out,
                const double *c,
                int n,
                ...);

Perform VIPS_OPERATION_MATH2_POW on an image and a constant. See vips_math2_const().

[method]

vips_wop_const ()

int
vips_wop_const (VipsImage *in,
                VipsImage **out,
                const double *c,
                int n,
                ...);

Perform VIPS_OPERATION_MATH2_WOP on an image and a constant. See vips_math2_const().

[method]

vips_math2_const1 ()

int
vips_math2_const1 (VipsImage *in,
                   VipsImage **out,
                   VipsOperationMath2 math2,
                   double c,
                   ...);

This operation calculates various 2-ary maths operations on an image and a constant. See vips_math2_const().

[method]

vips_pow_const1 ()

int
vips_pow_const1 (VipsImage *in,
                 VipsImage **out,
                 double c,
                 ...);

Perform VIPS_OPERATION_MATH2_POW on an image and a constant. See vips_math2_const().

[method]

vips_wop_const1 ()

int
vips_wop_const1 (VipsImage *in,
                 VipsImage **out,
                 double c,
                 ...);

Perform VIPS_OPERATION_MATH2_WOP on an image and a constant. See vips_math2_const().

[method]

vips_avg ()

int
vips_avg (VipsImage *in,
          double *out,
          ...);

This operation finds the average value in an image. It operates on all bands of the input image: use vips_stats() if you need to calculate an average for each band. For complex images, return the average modulus.

See also: vips_stats(), vips_bandmean(), vips_deviate(), vips_rank()

[method]

vips_deviate ()

int
vips_deviate (VipsImage *in,
              double *out,
              ...);

This operation finds the standard deviation of all pixels in in . It operates on all bands of the input image: use vips_stats() if you need to calculate an average for each band.

Non-complex images only.

See also: vips_avg(), vips_stats()..

[method]

vips_min ()

int
vips_min (VipsImage *in,
          double *out,
          ...);