mask

mask — load, save and process mask (matrix) objects

Stability Level

Stable, unless otherwise indicated

Synopsis


#include <vips/vips.h>

                    INTMASK;
                    DOUBLEMASK;
INTMASK *           im_create_imask                     (const char *name,
                                                         int width,
                                                         int height);
INTMASK *           im_create_imaskv                    (const char *name,
                                                         int width,
                                                         int height,
                                                         ...);
DOUBLEMASK *        im_create_dmask                     (const char *name,
                                                         int width,
                                                         int height);
DOUBLEMASK *        im_create_dmaskv                    (const char *name,
                                                         int width,
                                                         int height,
                                                         ...);
INTMASK *           im_read_imask                       (const char *filename);
DOUBLEMASK *        im_read_dmask                       (const char *filename);
void                im_print_imask                      (INTMASK *m);
void                im_print_dmask                      (DOUBLEMASK *m);
int                 im_write_imask                      (INTMASK *m);
int                 im_write_dmask                      (DOUBLEMASK *m);
int                 im_write_imask_name                 (INTMASK *m,
                                                         const char *filename);
int                 im_write_dmask_name                 (DOUBLEMASK *m,
                                                         const char *filename);
int                 im_free_imask                       (INTMASK *m);
int                 im_free_dmask                       (DOUBLEMASK *m);
INTMASK *           im_log_imask                        (const char *filename,
                                                         double sigma,
                                                         double min_ampl);
DOUBLEMASK *        im_log_dmask                        (const char *filename,
                                                         double sigma,
                                                         double min_ampl);
INTMASK *           im_gauss_imask                      (const char *filename,
                                                         double sigma,
                                                         double min_ampl);
INTMASK *           im_gauss_imask_sep                  (const char *filename,
                                                         double sigma,
                                                         double min_ampl);
DOUBLEMASK *        im_gauss_dmask                      (const char *filename,
                                                         double sigma,
                                                         double min_ampl);
INTMASK *           im_dup_imask                        (INTMASK *m,
                                                         const char *name);
DOUBLEMASK *        im_dup_dmask                        (DOUBLEMASK *m,
                                                         const char *name);
INTMASK *           im_scale_dmask                      (DOUBLEMASK *m,
                                                         const char *filename);
void                im_norm_dmask                       (DOUBLEMASK *mask);
int *               im_offsets45                        (int size);
int *               im_offsets90                        (int size);
INTMASK *           im_rotate_imask90                   (INTMASK *m,
                                                         const char *filename);
INTMASK *           im_rotate_imask45                   (INTMASK *m,
                                                         const char *filename);
DOUBLEMASK *        im_rotate_dmask90                   (DOUBLEMASK *m,
                                                         const char *filename);
DOUBLEMASK *        im_rotate_dmask45                   (DOUBLEMASK *m,
                                                         const char *filename);
DOUBLEMASK *        im_mattrn                           (DOUBLEMASK *in,
                                                         const char *name);
DOUBLEMASK *        im_matcat                           (DOUBLEMASK *in1,
                                                         DOUBLEMASK *in2,
                                                         const char *name);
DOUBLEMASK *        im_matmul                           (DOUBLEMASK *in1,
                                                         DOUBLEMASK *in2,
                                                         const char *name);
DOUBLEMASK *        im_lu_decomp                        (const DOUBLEMASK *mat,
                                                         const char *name);
int                 im_lu_solve                         (const DOUBLEMASK *lu,
                                                         double *vec);
DOUBLEMASK *        im_matinv                           (const DOUBLEMASK *mat,
                                                         const char *name);
int                 im_matinv_inplace                   (DOUBLEMASK *mat);

Description

These operations load, save and process mask objects. Masks are used as paramaters to convolution and morphology operators, and to represent matrices.

This API is horrible and clunky. Surely it will be replaced soon.

Details

INTMASK

typedef struct {
	int xsize;
	int ysize;
	int scale;
	int offset;
	int *coeff;
	char *filename;
} INTMASK;

DOUBLEMASK

typedef struct {
	int xsize;
	int ysize;
	double scale;
	double offset;
	double *coeff;
	char *filename;
} DOUBLEMASK;

im_create_imask ()

INTMASK *           im_create_imask                     (const char *name,
                                                         int width,
                                                         int height);

im_create_imaskv ()

INTMASK *           im_create_imaskv                    (const char *name,
                                                         int width,
                                                         int height,
                                                         ...);

im_create_dmask ()

DOUBLEMASK *        im_create_dmask                     (const char *name,
                                                         int width,
                                                         int height);

im_create_dmaskv ()

DOUBLEMASK *        im_create_dmaskv                    (const char *name,
                                                         int width,
                                                         int height,
                                                         ...);

im_read_imask ()

INTMASK *           im_read_imask                       (const char *filename);

im_read_dmask ()

DOUBLEMASK *        im_read_dmask                       (const char *filename);

im_print_imask ()

void                im_print_imask                      (INTMASK *m);

im_print_dmask ()

void                im_print_dmask                      (DOUBLEMASK *m);

im_write_imask ()

int                 im_write_imask                      (INTMASK *m);

im_write_dmask ()

int                 im_write_dmask                      (DOUBLEMASK *m);

im_write_imask_name ()

int                 im_write_imask_name                 (INTMASK *m,
                                                         const char *filename);

im_write_dmask_name ()

int                 im_write_dmask_name                 (DOUBLEMASK *m,
                                                         const char *filename);

im_free_imask ()

int                 im_free_imask                       (INTMASK *m);

im_free_dmask ()

int                 im_free_dmask                       (DOUBLEMASK *m);

im_log_imask ()

INTMASK *           im_log_imask                        (const char *filename,
                                                         double sigma,
                                                         double min_ampl);

im_log_dmask ()

DOUBLEMASK *        im_log_dmask                        (const char *filename,
                                                         double sigma,
                                                         double min_ampl);

im_gauss_imask ()

INTMASK *           im_gauss_imask                      (const char *filename,
                                                         double sigma,
                                                         double min_ampl);

im_gauss_imask_sep ()

INTMASK *           im_gauss_imask_sep                  (const char *filename,
                                                         double sigma,
                                                         double min_ampl);

im_gauss_dmask ()

DOUBLEMASK *        im_gauss_dmask                      (const char *filename,
                                                         double sigma,
                                                         double min_ampl);

im_dup_imask ()

INTMASK *           im_dup_imask                        (INTMASK *m,
                                                         const char *name);

im_dup_dmask ()

DOUBLEMASK *        im_dup_dmask                        (DOUBLEMASK *m,
                                                         const char *name);

im_scale_dmask ()

INTMASK *           im_scale_dmask                      (DOUBLEMASK *m,
                                                         const char *filename);

im_norm_dmask ()

void                im_norm_dmask                       (DOUBLEMASK *mask);

im_offsets45 ()

int *               im_offsets45                        (int size);

im_offsets90 ()

int *               im_offsets90                        (int size);

im_rotate_imask90 ()

INTMASK *           im_rotate_imask90                   (INTMASK *m,
                                                         const char *filename);

im_rotate_imask45 ()

INTMASK *           im_rotate_imask45                   (INTMASK *m,
                                                         const char *filename);

im_rotate_dmask90 ()

DOUBLEMASK *        im_rotate_dmask90                   (DOUBLEMASK *m,
                                                         const char *filename);

im_rotate_dmask45 ()

DOUBLEMASK *        im_rotate_dmask45                   (DOUBLEMASK *m,
                                                         const char *filename);

im_mattrn ()

DOUBLEMASK *        im_mattrn                           (DOUBLEMASK *in,
                                                         const char *name);

im_matcat ()

DOUBLEMASK *        im_matcat                           (DOUBLEMASK *in1,
                                                         DOUBLEMASK *in2,
                                                         const char *name);

im_matmul ()

DOUBLEMASK *        im_matmul                           (DOUBLEMASK *in1,
                                                         DOUBLEMASK *in2,
                                                         const char *name);

im_lu_decomp ()

DOUBLEMASK *        im_lu_decomp                        (const DOUBLEMASK *mat,
                                                         const char *name);

im_lu_solve ()

int                 im_lu_solve                         (const DOUBLEMASK *lu,
                                                         double *vec);

im_matinv ()

DOUBLEMASK *        im_matinv                           (const DOUBLEMASK *mat,
                                                         const char *name);

im_matinv_inplace ()

int                 im_matinv_inplace                   (DOUBLEMASK *mat);