other

other — miscellaneous operators

Stability Level

Stable, unless otherwise indicated

Synopsis

#include <vips/vips.h>

int                 im_feye                             (IMAGE *image,
                                                         const int xsize,
                                                         const int ysize,
                                                         const double factor);
int                 im_eye                              (IMAGE *image,
                                                         const int xsize,
                                                         const int ysize,
                                                         const double factor);
int                 im_zone                             (IMAGE *im,
                                                         int size);
int                 im_fzone                            (IMAGE *im,
                                                         int size);
int                 im_grey                             (IMAGE *im,
                                                         const int xsize,
                                                         const int ysize);
int                 im_fgrey                            (IMAGE *im,
                                                         const int xsize,
                                                         const int ysize);
int                 im_make_xy                          (IMAGE *out,
                                                         const int xsize,
                                                         const int ysize);
int                 im_benchmarkn                       (IMAGE *in,
                                                         IMAGE *out,
                                                         int n);
int                 im_benchmark2                       (IMAGE *in,
                                                         double *out);
int                 im_cooc_matrix                      (IMAGE *im,
                                                         IMAGE *m,
                                                         int xp,
                                                         int yp,
                                                         int xs,
                                                         int ys,
                                                         int dx,
                                                         int dy,
                                                         int flag);
int                 im_cooc_asm                         (IMAGE *m,
                                                         double *asmoment);
int                 im_cooc_contrast                    (IMAGE *m,
                                                         double *contrast);
int                 im_cooc_correlation                 (IMAGE *m,
                                                         double *correlation);
int                 im_cooc_entropy                     (IMAGE *m,
                                                         double *entropy);
int                 im_glds_matrix                      (IMAGE *im,
                                                         IMAGE *m,
                                                         int xpos,
                                                         int ypos,
                                                         int xsize,
                                                         int ysize,
                                                         int dx,
                                                         int dy);
int                 im_glds_asm                         (IMAGE *m,
                                                         double *asmoment);
int                 im_glds_contrast                    (IMAGE *m,
                                                         double *contrast);
int                 im_glds_entropy                     (IMAGE *m,
                                                         double *entropy);
int                 im_glds_mean                        (IMAGE *m,
                                                         double *mean);
int                 im_simcontr                         (IMAGE *image,
                                                         int xs,
                                                         int ys);
int                 im_sines                            (IMAGE *image,
                                                         int xsize,
                                                         int ysize,
                                                         double horfreq,
                                                         double verfreq);
int                 im_spatres                          (IMAGE *in,
                                                         IMAGE *out,
                                                         int step);

Description

Various small things.

Details

im_feye ()

int                 im_feye                             (IMAGE *image,
                                                         const int xsize,
                                                         const int ysize,
                                                         const double factor);

im_eye ()

int                 im_eye                              (IMAGE *image,
                                                         const int xsize,
                                                         const int ysize,
                                                         const double factor);

im_zone ()

int                 im_zone                             (IMAGE *im,
                                                         int size);

im_fzone ()

int                 im_fzone                            (IMAGE *im,
                                                         int size);

im_grey ()

int                 im_grey                             (IMAGE *im,
                                                         const int xsize,
                                                         const int ysize);

im_fgrey ()

int                 im_fgrey                            (IMAGE *im,
                                                         const int xsize,
                                                         const int ysize);

im_make_xy ()

int                 im_make_xy                          (IMAGE *out,
                                                         const int xsize,
                                                         const int ysize);

im_benchmarkn ()

int                 im_benchmarkn                       (IMAGE *in,
                                                         IMAGE *out,
                                                         int n);

im_benchmark2 ()

int                 im_benchmark2                       (IMAGE *in,
                                                         double *out);

im_cooc_matrix ()

int                 im_cooc_matrix                      (IMAGE *im,
                                                         IMAGE *m,
                                                         int xp,
                                                         int yp,
                                                         int xs,
                                                         int ys,
                                                         int dx,
                                                         int dy,
                                                         int flag);

im_cooc_asm ()

int                 im_cooc_asm                         (IMAGE *m,
                                                         double *asmoment);

im_cooc_contrast ()

int                 im_cooc_contrast                    (IMAGE *m,
                                                         double *contrast);

im_cooc_correlation ()

int                 im_cooc_correlation                 (IMAGE *m,
                                                         double *correlation);

im_cooc_entropy ()

int                 im_cooc_entropy                     (IMAGE *m,
                                                         double *entropy);

im_glds_matrix ()

int                 im_glds_matrix                      (IMAGE *im,
                                                         IMAGE *m,
                                                         int xpos,
                                                         int ypos,
                                                         int xsize,
                                                         int ysize,
                                                         int dx,
                                                         int dy);

im_glds_asm ()

int                 im_glds_asm                         (IMAGE *m,
                                                         double *asmoment);

im_glds_contrast ()

int                 im_glds_contrast                    (IMAGE *m,
                                                         double *contrast);

im_glds_entropy ()

int                 im_glds_entropy                     (IMAGE *m,
                                                         double *entropy);

im_glds_mean ()

int                 im_glds_mean                        (IMAGE *m,
                                                         double *mean);

im_simcontr ()

int                 im_simcontr                         (IMAGE *image,
                                                         int xs,
                                                         int ys);

im_sines ()

int                 im_sines                            (IMAGE *image,
                                                         int xsize,
                                                         int ysize,
                                                         double horfreq,
                                                         double verfreq);

im_spatres ()

int                 im_spatres                          (IMAGE *in,
                                                         IMAGE *out,
                                                         int step);