/* Function dispatch tables for other.
 *
 * J. Cupitt, 8/2/95
 */

/*

	This file is part of VIPS.

	VIPS is free software; you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	02110-1301  USA

 */

/*

	These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk

 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /*HAVE_CONFIG_H*/
#include <glib/gi18n-lib.h>

#include <stdio.h>

#include <vips/vips.h>
#include <vips/vips7compat.h>

/* Args for im_sines.
 */
static im_arg_desc sines_args[] = {
	IM_OUTPUT_IMAGE("out"),
	IM_INPUT_INT("xsize"),
	IM_INPUT_INT("ysize"),
	IM_INPUT_DOUBLE("horfreq"),
	IM_INPUT_DOUBLE("verfreq")
};

/* Call im_sines via arg vector.
 */
static int
sines_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);
	double horfreq = *((double *) argv[3]);
	double verfreq = *((double *) argv[4]);

	return im_sines(argv[0], xsize, ysize, horfreq, verfreq);
}

/* Description of im_sines.
 */
static im_function sines_desc = {
	"im_sines", /* Name */
	"generate 2D sine image",
	0,					   /* Flags */
	sines_vec,			   /* Dispatch function */
	IM_NUMBER(sines_args), /* Size of arg list */
	sines_args			   /* Arg list */
};

/* Args for im_eye.
 */
static im_arg_desc eye_args[] = {
	IM_OUTPUT_IMAGE("out"),
	IM_INPUT_INT("xsize"),
	IM_INPUT_INT("ysize"),
	IM_INPUT_DOUBLE("factor")
};

/* Call im_eye via arg vector.
 */
static int
eye_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);
	double factor = *((double *) argv[3]);

	return im_eye(argv[0], xsize, ysize, factor);
}

/* Description of im_eye.
 */
static im_function eye_desc = {
	"im_eye", /* Name */
	"generate IM_BANDFMT_UCHAR [0,255] frequency/amplitude image",
	0,					 /* Flags */
	eye_vec,			 /* Dispatch function */
	IM_NUMBER(eye_args), /* Size of arg list */
	eye_args			 /* Arg list */
};

/* Call im_feye via arg vector.
 */
static int
feye_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);
	double factor = *((double *) argv[3]);

	return im_feye(argv[0], xsize, ysize, factor);
}

/* Description of im_feye.
 */
static im_function feye_desc = {
	"im_feye", /* Name */
	"generate IM_BANDFMT_FLOAT [-1,1] frequency/amplitude image",
	0,					 /* Flags */
	feye_vec,			 /* Dispatch function */
	IM_NUMBER(eye_args), /* Size of arg list */
	eye_args			 /* Arg list */
};

/* Args for im_zone.
 */
static im_arg_desc zone_args[] = {
	IM_OUTPUT_IMAGE("out"),
	IM_INPUT_INT("size")
};

/* Call im_zone via arg vector.
 */
static int
zone_vec(im_object *argv)
{
	int size = *((int *) argv[1]);

	return im_zone(argv[0], size);
}

/* Description of im_zone.
 */
static im_function zone_desc = {
	"im_zone",											  /* Name */
	"generate IM_BANDFMT_UCHAR [0,255] zone plate image", /* Description */
	0,													  /* Flags */
	zone_vec,											  /* Dispatch function */
	IM_NUMBER(zone_args),								  /* Size of arg list */
	zone_args											  /* Arg list */
};

/* Call im_fzone via arg vector.
 */
static int
fzone_vec(im_object *argv)
{
	int size = *((int *) argv[1]);

	return im_fzone(argv[0], size);
}

/* Description of im_fzone.
 */
static im_function fzone_desc = {
	"im_fzone",											 /* Name */
	"generate IM_BANDFMT_FLOAT [-1,1] zone plate image", /* Description */
	0,													 /* Flags */
	fzone_vec,											 /* Dispatch function */
	IM_NUMBER(zone_args),								 /* Size of arg list */
	zone_args											 /* Arg list */
};

/* Args for im_benchmark.
 */
static im_arg_desc benchmark_args[] = {
	IM_INPUT_IMAGE("in"),
	IM_OUTPUT_IMAGE("out")
};

/* Call im_benchmark via arg vector.
 */
static int
benchmark_vec(im_object *argv)
{
	return im_benchmarkn(argv[0], argv[1], 1);
}

/* Description of im_benchmark.
 */
static im_function benchmark_desc = {
	"im_benchmark",							/* Name */
	"do something complicated for testing", /* Description */
	IM_FN_PIO,								/* Flags */
	benchmark_vec,							/* Dispatch function */
	IM_NUMBER(benchmark_args),				/* Size of arg list */
	benchmark_args							/* Arg list */
};

/* Args for im_benchmark2.
 */
static im_arg_desc benchmark2_args[] = {
	IM_INPUT_IMAGE("in"),
	IM_OUTPUT_DOUBLE("value")
};

/* Call im_benchmark2 via arg vector.
 */
static int
benchmark2_vec(im_object *argv)
{
	double f;

	if (im_benchmark2(argv[0], &f))
		return -1;

	*((double *) argv[1]) = f;

	return 0;
}

/* Description of im_benchmark2.
 */
static im_function benchmark2_desc = {
	"im_benchmark2",						/* Name */
	"do something complicated for testing", /* Description */
	IM_FN_PIO,								/* Flags */
	benchmark2_vec,							/* Dispatch function */
	IM_NUMBER(benchmark2_args),				/* Size of arg list */
	benchmark2_args							/* Arg list */
};

/* Args for im_benchmarkn.
 */
static im_arg_desc benchmarkn_args[] = {
	IM_INPUT_IMAGE("in"),
	IM_OUTPUT_IMAGE("out"),
	IM_INPUT_INT("n")
};

/* Call im_benchmarkn via arg vector.
 */
static int
benchmarkn_vec(im_object *argv)
{
	int n = *((int *) argv[2]);

	return im_benchmarkn(argv[0], argv[1], n);
}

/* Description of im_benchmarkn.
 */
static im_function benchmarkn_desc = {
	"im_benchmarkn",						/* Name */
	"do something complicated for testing", /* Description */
	IM_FN_PIO,								/* Flags */
	benchmarkn_vec,							/* Dispatch function */
	IM_NUMBER(benchmarkn_args),				/* Size of arg list */
	benchmarkn_args							/* Arg list */
};

/* Args for im_grey.
 */
static im_arg_desc grey_args[] = {
	IM_OUTPUT_IMAGE("out"),
	IM_INPUT_INT("xsize"),
	IM_INPUT_INT("ysize")
};

/* Call im_grey via arg vector.
 */
static int
grey_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);

	return im_grey(argv[0], xsize, ysize);
}

/* Description of im_grey.
 */
static im_function grey_desc = {
	"im_grey",											  /* Name */
	"generate IM_BANDFMT_UCHAR [0,255] grey scale image", /* Description */
	0,													  /* Flags */
	grey_vec,											  /* Dispatch function */
	IM_NUMBER(grey_args),								  /* Size of arg list */
	grey_args											  /* Arg list */
};

/* Call im_fgrey via arg vector.
 */
static int
fgrey_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);

	return im_fgrey(argv[0], xsize, ysize);
}

/* Description of im_fgrey.
 */
static im_function fgrey_desc = {
	"im_fgrey",											/* Name */
	"generate IM_BANDFMT_FLOAT [0,1] grey scale image", /* Description */
	0,													/* Flags */
	fgrey_vec,											/* Dispatch function */
	IM_NUMBER(grey_args),								/* Size of arg list */
	grey_args											/* Arg list */
};

/* Call im_make_xy via arg vector.
 */
static int
make_xy_vec(im_object *argv)
{
	int xsize = *((int *) argv[1]);
	int ysize = *((int *) argv[2]);

	return im_make_xy(argv[0], xsize, ysize);
}

/* Description of im_make_xy.
 */
static im_function make_xy_desc = {
	"im_make_xy",										   /* Name */
	"generate image with pixel value equal to coordinate", /* Description */
	0,													   /* Flags */
	make_xy_vec,										   /* Dispatch function */
	IM_NUMBER(grey_args),								   /* Size of arg list */
	grey_args											   /* Arg list */
};

/* Package up all these functions.
 */
static im_function *other_list[] = {
	&benchmark_desc,
	&benchmark2_desc,
	&benchmarkn_desc,
	&eye_desc,
	&grey_desc,
	&feye_desc,
	&fgrey_desc,
	&fzone_desc,
	&make_xy_desc,
	&sines_desc,
	&zone_desc
};

/* Package of functions.
 */
im_package im__other = {
	"other",
	IM_NUMBER(other_list),
	other_list
};
