dispatch

dispatch

Synopsis

#define             IM_TYPE_IMAGEVEC
#define             IM_TYPE_DOUBLEVEC
#define             IM_TYPE_INTVEC
#define             IM_TYPE_DOUBLE
#define             IM_TYPE_INT
#define             IM_TYPE_COMPLEX
#define             IM_TYPE_STRING
#define             IM_TYPE_IMASK
#define             IM_TYPE_DMASK
#define             IM_TYPE_IMAGE
#define             IM_TYPE_DISPLAY
#define             IM_TYPE_GVALUE
#define             IM_TYPE_INTERPOLATE
typedef             im_arg_type;
typedef             im_object;
enum                im_type_flags;
int                 (*im_init_obj_fn)                   (im_object *obj,
                                                         char *str);
int                 (*im_dest_obj_fn)                   (im_object obj);
                    im_type_desc;
int                 (*im_print_obj_fn)                  (im_object obj);
                    im_arg_desc;
int                 (*im_dispatch_fn)                   (im_object *argv);
#define             IM_MAX_ARGS
enum                im_fn_flags;
                    im_function;
                    im_package;
                    im_mask_object;
                    im_doublevec_object;
                    im_intvec_object;
                    im_imagevec_object;
extern              im_type_desc im__input_int;
extern              im_type_desc im__input_intvec;
extern              im_type_desc im__input_imask;
extern              im_type_desc im__output_int;
extern              im_type_desc im__output_intvec;
extern              im_type_desc im__output_imask;
extern              im_type_desc im__input_double;
extern              im_type_desc im__input_doublevec;
extern              im_type_desc im__input_dmask;
extern              im_type_desc im__output_double;
extern              im_type_desc im__output_doublevec;
extern              im_type_desc im__output_dmask;
extern              im_type_desc im__output_dmask_screen;
extern              im_type_desc im__output_complex;
extern              im_type_desc im__input_string;
extern              im_type_desc im__output_string;
extern              im_type_desc im__input_imagevec;
extern              im_type_desc im__input_image;
extern              im_type_desc im__output_image;
extern              im_type_desc im__rw_image;
extern              im_type_desc im__input_display;
extern              im_type_desc im__output_display;
extern              im_type_desc im__input_gvalue;
extern              im_type_desc im__output_gvalue;
extern              im_type_desc im__input_interpolate;
int                 im__iprint                          (im_object obj);
int                 im__ivprint                         (im_object obj);
int                 im__dprint                          (im_object obj);
int                 im__dvprint                         (im_object obj);
int                 im__dmsprint                        (im_object obj);
int                 im__cprint                          (im_object obj);
int                 im__sprint                          (im_object obj);
int                 im__displayprint                    (im_object obj);
int                 im__gprint                          (im_object obj);
#define             IM_INPUT_INT                        ( S )
#define             IM_INPUT_INTVEC                     ( S )
#define             IM_INPUT_IMASK                      ( S )
#define             IM_OUTPUT_INT                       ( S )
#define             IM_OUTPUT_INTVEC                    ( S )
#define             IM_OUTPUT_IMASK                     ( S )
#define             IM_INPUT_DOUBLE                     ( S )
#define             IM_INPUT_DOUBLEVEC                  ( S )
#define             IM_INPUT_DMASK                      ( S )
#define             IM_OUTPUT_DOUBLE                    ( S )
#define             IM_OUTPUT_DOUBLEVEC                 ( S )
#define             IM_OUTPUT_DMASK                     ( S )
#define             IM_OUTPUT_DMASK_STATS               ( S )
#define             IM_OUTPUT_COMPLEX                   ( S )
#define             IM_INPUT_STRING                     ( S )
#define             IM_OUTPUT_STRING                    ( S )
#define             IM_INPUT_IMAGE                      ( S )
#define             IM_INPUT_IMAGEVEC                   ( S )
#define             IM_OUTPUT_IMAGE                     ( S )
#define             IM_RW_IMAGE                         ( S )
#define             IM_INPUT_DISPLAY                    ( S )
#define             IM_OUTPUT_DISPLAY                   ( S )
#define             IM_INPUT_GVALUE                     ( S )
#define             IM_OUTPUT_GVALUE                    ( S )
#define             IM_INPUT_INTERPOLATE                ( S )
im_package *        im_load_plugin                      (const char *name);
int                 im_load_plugins                     (const char *fmt,
                                                         ...);
int                 im_close_plugins                    (void);
void *              im_map_packages                     (VSListMap2Fn fn,
                                                         void *a);
im_function *       im_find_function                    (const char *name);
im_package *        im_find_package                     (const char *name);
im_package *        im_package_of_function              (const char *name);
int                 im_free_vargv                       (im_function *fn,
                                                         im_object *vargv);
int                 im_allocate_vargv                   (im_function *fn,
                                                         im_object *vargv);
int                 im_run_command                      (char *name,
                                                         int argc,
                                                         char **argv);

Description

Details

IM_TYPE_IMAGEVEC

#define IM_TYPE_IMAGEVEC "imagevec"	/* im_object is ptr to IMAGE[] */

IM_TYPE_DOUBLEVEC

#define IM_TYPE_DOUBLEVEC "doublevec"	/* im_object is ptr to double[] */

IM_TYPE_INTVEC

#define IM_TYPE_INTVEC "intvec"		/* im_object is ptr to int[] */

IM_TYPE_DOUBLE

#define IM_TYPE_DOUBLE "double"		/* im_object is ptr to double */

IM_TYPE_INT

#define IM_TYPE_INT "integer"		/* 32-bit integer */

IM_TYPE_COMPLEX

#define IM_TYPE_COMPLEX "complex"	/* Pair of doubles */

IM_TYPE_STRING

#define IM_TYPE_STRING "string"         /* Zero-terminated char array */

IM_TYPE_IMASK

#define IM_TYPE_IMASK "intmask"		/* Integer mask type */

IM_TYPE_DMASK

#define IM_TYPE_DMASK "doublemask"	/* Double mask type */

IM_TYPE_IMAGE

#define IM_TYPE_IMAGE "image"           /* IMAGE descriptor */

IM_TYPE_DISPLAY

#define IM_TYPE_DISPLAY "display"	/* Display descriptor */

IM_TYPE_GVALUE

#define IM_TYPE_GVALUE "gvalue"		/* GValue wrapper */

IM_TYPE_INTERPOLATE

#define IM_TYPE_INTERPOLATE "interpolate"/* A subclass of VipsInterpolate */

im_arg_type

typedef char *im_arg_type;              /* Type of argument id */

im_object

typedef void *im_object;

enum im_type_flags

typedef enum {
	IM_TYPE_NONE = 0,		/* No flags */
	IM_TYPE_OUTPUT = 0x1,		/* Output/input object */
	IM_TYPE_ARG = 0x2		/* Uses a str arg in construction */
} im_type_flags;

im_init_obj_fn ()

int                 (*im_init_obj_fn)                   (im_object *obj,
                                                         char *str);

im_dest_obj_fn ()

int                 (*im_dest_obj_fn)                   (im_object obj);

im_type_desc

typedef struct {
	im_arg_type type;		/* Type of argument */
	int size;			/* sizeof( im_object repres. ) */
	im_type_flags flags;		/* Flags */
	im_init_obj_fn init; 		/* Operation functions */
	im_dest_obj_fn dest;            /* Destroy object */
} im_type_desc;

im_print_obj_fn ()

int                 (*im_print_obj_fn)                  (im_object obj);

im_arg_desc

typedef struct {
	char *name;			/* eg. "width" */
	im_type_desc *desc; 		/* Type description */
	im_print_obj_fn print;		/* Print some output objects */
} im_arg_desc;

im_dispatch_fn ()

int                 (*im_dispatch_fn)                   (im_object *argv);

IM_MAX_ARGS

#define IM_MAX_ARGS (1000)

enum im_fn_flags

typedef enum {
	IM_FN_NONE = 0,		/* No flags set */
	IM_FN_PIO = 0x1,	/* Is a partial function */
	IM_FN_TRANSFORM = 0x2,	/* Performs coordinate transformations */
	IM_FN_PTOP = 0x4,	/* Point-to-point ... can be done with a LUT */
	IM_FN_NOCACHE = 0x8	/* Result should not be cached */
} im_fn_flags;

im_function

typedef struct {
	char *name;		/* eg "im_invert" */
	char *desc;		/* Description - eg "photographic negative" */
	im_fn_flags flags;	/* Flags for this function */
	im_dispatch_fn disp;	/* Dispatch */
	int argc;		/* Number of args */
	im_arg_desc *argv; 	/* Arg table */
} im_function;

im_package

typedef struct {
	char *name;		/* Package name (eg "arithmetic") */
	int nfuncs;		/* Number of functions in package */
	im_function **table;	/* Array of function descriptors */
} im_package;

im_mask_object

typedef struct {
	char *name;		/* Command-line name in */
	void *mask;		/* Mask --- DOUBLE or INT */
} im_mask_object;

im_doublevec_object

typedef struct {
	int n;			/* Vector length */
	double *vec;		/* Vector */
} im_doublevec_object;

im_intvec_object

typedef struct {
	int n;			/* Vector length */
	int *vec;		/* Vector */
} im_intvec_object;

im_imagevec_object

typedef struct {
	int n;			/* Vector length */
	IMAGE **vec;		/* Vector */
} im_imagevec_object;

im__input_int

extern im_type_desc im__input_int;

im__input_intvec

extern im_type_desc im__input_intvec;

im__input_imask

extern im_type_desc im__input_imask;

im__output_int

extern im_type_desc im__output_int;

im__output_intvec

extern im_type_desc im__output_intvec;

im__output_imask

extern im_type_desc im__output_imask;

im__input_double

extern im_type_desc im__input_double;

im__input_doublevec

extern im_type_desc im__input_doublevec;

im__input_dmask

extern im_type_desc im__input_dmask;

im__output_double

extern im_type_desc im__output_double;

im__output_doublevec

extern im_type_desc im__output_doublevec;

im__output_dmask

extern im_type_desc im__output_dmask;

im__output_dmask_screen

extern im_type_desc im__output_dmask_screen;

im__output_complex

extern im_type_desc im__output_complex;

im__input_string

extern im_type_desc im__input_string;

im__output_string

extern im_type_desc im__output_string;

im__input_imagevec

extern im_type_desc im__input_imagevec;

im__input_image

extern im_type_desc im__input_image;

im__output_image

extern im_type_desc im__output_image;

im__rw_image

extern im_type_desc im__rw_image;

im__input_display

extern im_type_desc im__input_display;

im__output_display

extern im_type_desc im__output_display;

im__input_gvalue

extern im_type_desc im__input_gvalue;

im__output_gvalue

extern im_type_desc im__output_gvalue;

im__input_interpolate

extern im_type_desc im__input_interpolate;

im__iprint ()

int                 im__iprint                          (im_object obj);

im__ivprint ()

int                 im__ivprint                         (im_object obj);

im__dprint ()

int                 im__dprint                          (im_object obj);

im__dvprint ()

int                 im__dvprint                         (im_object obj);

im__dmsprint ()

int                 im__dmsprint                        (im_object obj);

im__cprint ()

int                 im__cprint                          (im_object obj);

im__sprint ()

int                 im__sprint                          (im_object obj);

im__displayprint ()

int                 im__displayprint                    (im_object obj);

im__gprint ()

int                 im__gprint                          (im_object obj);

IM_INPUT_INT()

#define IM_INPUT_INT( S ) { S, &im__input_int, NULL }

IM_INPUT_INTVEC()

#define IM_INPUT_INTVEC( S ) { S, &im__input_intvec, NULL }

IM_INPUT_IMASK()

#define IM_INPUT_IMASK( S ) { S, &im__input_imask, NULL }

IM_OUTPUT_INT()

#define IM_OUTPUT_INT( S ) { S, &im__output_int, im__iprint }

IM_OUTPUT_INTVEC()

#define IM_OUTPUT_INTVEC( S ) { S, &im__output_intvec, im__ivprint }

IM_OUTPUT_IMASK()

#define IM_OUTPUT_IMASK( S ) { S, &im__output_imask, NULL }

IM_INPUT_DOUBLE()

#define IM_INPUT_DOUBLE( S ) { S, &im__input_double, NULL }

IM_INPUT_DOUBLEVEC()

#define IM_INPUT_DOUBLEVEC( S ) { S, &im__input_doublevec, NULL }

IM_INPUT_DMASK()

#define IM_INPUT_DMASK( S ) { S, &im__input_dmask, NULL }

IM_OUTPUT_DOUBLE()

#define IM_OUTPUT_DOUBLE( S ) { S, &im__output_double, im__dprint }

IM_OUTPUT_DOUBLEVEC()

#define IM_OUTPUT_DOUBLEVEC( S ) { S, &im__output_doublevec, im__dvprint }

IM_OUTPUT_DMASK()

#define IM_OUTPUT_DMASK( S ) { S, &im__output_dmask, NULL }

IM_OUTPUT_DMASK_STATS()

#define IM_OUTPUT_DMASK_STATS( S ) { S, &im__output_dmask_screen, im__dmsprint }

IM_OUTPUT_COMPLEX()

#define IM_OUTPUT_COMPLEX( S ) { S, &im__output_complex, im__cprint }

IM_INPUT_STRING()

#define IM_INPUT_STRING( S ) { S, &im__input_string, NULL }

IM_OUTPUT_STRING()

#define IM_OUTPUT_STRING( S ) { S, &im__output_string, im__sprint }

IM_INPUT_IMAGE()

#define IM_INPUT_IMAGE( S ) { S, &im__input_image, NULL }

IM_INPUT_IMAGEVEC()

#define IM_INPUT_IMAGEVEC( S ) { S, &im__input_imagevec, NULL }

IM_OUTPUT_IMAGE()

#define IM_OUTPUT_IMAGE( S ) { S, &im__output_image, NULL }

IM_RW_IMAGE()

#define IM_RW_IMAGE( S ) { S, &im__rw_image, NULL }

IM_INPUT_DISPLAY()

#define IM_INPUT_DISPLAY( S ) { S, &im__input_display, NULL }

IM_OUTPUT_DISPLAY()

#define IM_OUTPUT_DISPLAY( S ) { S, &im__output_display, im__displayprint }

IM_INPUT_GVALUE()

#define IM_INPUT_GVALUE( S ) { S, &im__input_gvalue, NULL }

IM_OUTPUT_GVALUE()

#define IM_OUTPUT_GVALUE( S ) { S, &im__output_gvalue, im__gprint }

IM_INPUT_INTERPOLATE()

#define IM_INPUT_INTERPOLATE( S ) { S, &im__input_interpolate, NULL }

im_load_plugin ()

im_package *        im_load_plugin                      (const char *name);

im_load_plugins ()

int                 im_load_plugins                     (const char *fmt,
                                                         ...);

im_close_plugins ()

int                 im_close_plugins                    (void);

im_map_packages ()

void *              im_map_packages                     (VSListMap2Fn fn,
                                                         void *a);

im_find_function ()

im_function *       im_find_function                    (const char *name);

im_find_package ()

im_package *        im_find_package                     (const char *name);

im_package_of_function ()

im_package *        im_package_of_function              (const char *name);

im_free_vargv ()

int                 im_free_vargv                       (im_function *fn,
                                                         im_object *vargv);

im_allocate_vargv ()

int                 im_allocate_vargv                   (im_function *fn,
                                                         im_object *vargv);

im_run_command ()

int                 im_run_command                      (char *name,
                                                         int argc,
                                                         char **argv);