void IFFT::help() {
pprintf("-ifft performs an inverse dft on the current image, whose values are"
" complex. The input and output are images with 2*c channels, where"
" channel 2*i is the real part of the i\'th channel, and channel 2*i+1"
" is the imaginary part of the i'th channel.\n"
"\n"
"Usage: ImageStack -load a.tga -fftcomplex -save freq.tga\n\n");
}
// added 28/01/2011 [email protected] void lcd_printf(char *fmt, ...) { va_list args; va_start(args, fmt); pprintf(lcd_write, fmt, args); va_end(args); }
void decl(void) {
char decl_type[MAXTOKEN];
decl_type[0] = '\0';
gettoken();
type(decl_type);
dcl();
pprintf("%s\n", decl_type);
}
/*
* asetemail
*
* Usage: asetemail player [address]
*
* Sets the email address of the player to the address given. If the
* address is omited, then the player's email address is cleared. The
* person's email address is revealed to them when they use the "finger"
* command, but no other users -- except admins -- will have another
* player's email address displayed.
*/
int com_asetemail(int p, param_list param)
{
struct player *pp = &player_globals.parray[p];
int p1, connected;
char *oldemail;
if (!FindPlayer(p, param[0].val.word, &p1, &connected))
return COM_OK;
if (!check_admin2(p, p1)) {
pprintf(p, "You can only set email addr for players below your adminlevel.\n");
if (!connected)
player_remove(p1);
return COM_OK;
}
if (player_globals.parray[p1].emailAddress) {
oldemail = strdup(player_globals.parray[p1].emailAddress);
free(player_globals.parray[p1].emailAddress);
} else {
oldemail = strdup("");
}
if (param[1].type == TYPE_NULL) {
player_globals.parray[p1].emailAddress = NULL;
pprintf(p, "Email address for %s removed\n", player_globals.parray[p1].name);
pcommand(p, "addcomment %s Email address removed.\n", player_globals.parray[p1].name);
} else {
player_globals.parray[p1].emailAddress = strdup(param[1].val.word);
pprintf(p, "Email address of %s changed to \"%s\".\n", player_globals.parray[p1].name, param[1].val.word);
pcommand(p, "addcomment %s Email address changed from %s to %s.\n", player_globals.parray[p1].name, oldemail, player_globals.parray[p1].emailAddress);
}
free(oldemail);
player_save(p1);
if (connected) {
if (param[1].type == TYPE_NULL) {
pprintf_prompt(p1, "\n\n%s has removed your email address.\n\n", pp->name);
} else {
pprintf_prompt(p1, "\n\n%s has changed your email address.\n\n", pp->name);
}
} else {
player_remove(p1);
}
return COM_OK;
}
static int
init_linemon(
queue_t *q
)
{
register queue_t *dq;
dq = WR(q);
/*
* we ARE doing very bad things down here (basically stealing ISR
* hooks)
*
* so we chase down the STREAMS stack searching for the driver
* and if this is a known driver we insert our ISR routine for
* status changes in to the ExternalStatus handling hook
*/
while (dq->q_next)
{
dq = dq->q_next; /* skip down to driver */
}
/*
* find appropriate driver dependent routine
*/
if (dq->q_qinfo && dq->q_qinfo->qi_minfo)
{
register char *dname = dq->q_qinfo->qi_minfo->mi_idname;
pprintf(DD_INSTALL, "init_linemon: driver is \"%s\"\n", dname);
#ifdef sun
if (dname && !strcmp(dname, "zs"))
{
return init_zs_linemon(dq, q);
}
else
#endif
{
pprintf(DD_INSTALL, "init_linemon: driver \"%s\" not suitable for CD monitoring\n", dname);
return 0;
}
}
pprintf(DD_INSTALL, "init_linemon: cannot find driver\n");
return 0;
}
void DCT::help() {
pprintf("-dct performs a real discrete cosine transform on the current"
" image, over the dimensions given in the argument. The signal is"
" treated as having reflective symmetry. If no arguments are"
" given, every dimension is transformed.\n"
"\n"
"Usage: ImageStack -load a.png -dct xy -save freq.png\n");
}
/*
* asetbug
*
* Usage: asetbug handle rating won lost drew RD
*
* This command allows admins to set a user's statistics for Bughouse
* games. The parameters are self-explanatory: rating, # of wins,
* # of losses, # of draws, and ratings deviation.
*/
int com_asetbug(int p, param_list param)
{
int p1, connected;
if (!FindPlayer(p, param[0].val.word, &p1, &connected))
return COM_OK;
if (CheckPFlag(p1, PFLAG_REG)) {
SetRating(p1, param, &player_globals.parray[p1].bug_stats);
player_save(p1);
pprintf(p, "Bughouse rating for %s modified.\n", player_globals.parray[p1].name);
} else
pprintf(p, "%s is unregistered. Can't modify rating.\n", player_globals.parray[p1].name);
if (!connected)
player_remove(p1);
return COM_OK;
}
static int netif_proc(struct proc_file *pf, void *arg) {
struct netif *netif;
for (netif = netif_list; netif != NULL; netif = netif->next) {
pprintf(pf, "%s: addr %a mask %a gw %a\n", netif->name, &netif->ipaddr, &netif->netmask, &netif->gw);
}
return 0;
}
void DimensionReduction::help() {
pprintf("-dimensionreduction takes a dimensionality and projects all points on"
" the image onto a linear subspace of best fit with that number of"
" dimensions. It is useful if you know an image should be low"
" dimensional (eg a sunset is mostly shades or red), and components"
" orthogonal to that dimension are unwanted (eg chromatic"
" abberation).\n\n"
"Usage: ImageStack -load sunset.jpg -dimensionreduction 2 -save fixed.jpg\n\n");
}
void Equalize::help() {
pprintf("-equalize flattens out the histogram of an image, while preserving ordering"
" between pixel brightnesses. It does this independently in each channel. When"
" given no arguments, it produces an image with values between zero and one. With"
" one argument, it produces values between zero and that argument. With two"
" arguments, it produces values between the two arguments. The brightest pixel(s)"
" will always map to the upper bound and the dimmest to the lower bound.\n\n"
"Usage: ImageStack -load a.tga -equalize 0.2 0.8 -save out.tga\n\n");
}
static int sys_converged (equation_system *sys, double *llbak,
gretlopt opt, PRN *prn, int *err)
{
double crit, tol = 0.0;
int met = 0;
if (sys->method == SYS_METHOD_SUR ||
sys->method == SYS_METHOD_WLS) {
double ll = sur_loglik(sys);
tol = SYS_LL_TOL;
crit = ll - *llbak;
if (opt & OPT_V) {
pprintf(prn, "Iteration %3d, ll = %#.8g\n", sys->iters, ll);
}
if (crit <= tol) {
met = 1;
} else if (sys->iters < SYS_MAX_ITER) {
*llbak = ll;
}
} else if (sys->method == SYS_METHOD_3SLS) {
tol = SYS_BDIFF_TOL;
crit = sys->bdiff;
if (opt & OPT_V) {
pprintf(prn, "Iteration %3d, criterion = %g\n", sys->iters, crit);
}
if (crit <= tol) {
met = 1;
}
}
if (met && tol > 0 && (opt & OPT_V)) {
pprintf(prn, "Tolerance of %g is met\n", tol);
}
if (!met && sys->iters >= SYS_MAX_ITER) {
pprintf(prn, "Reached %d iterations without meeting "
"tolerance of %g\n", sys->iters, tol);
*err = E_NOCONV;
}
return met;
}
static void function_noargs_error (const char *s, parser *p)
{
parser_print_input(p);
pprintf(p->prn, _("'%s': no argument was given"), s);
pputc(p->prn, '\n');
gretl_errmsg_sprintf(_("'%s': no argument was given"), s);
p->err = E_ARGS;
}
int gretl_array_print (gretl_array *A, PRN *prn)
{
if (A != NULL) {
const char *s = gretl_type_get_name(A->type);
pprintf(prn, _("Array of %s, length %d\n"), s, A->n);
}
return 0;
}
void ComplexDivide::help() {
pprintf("-complexdivide divides the top image in the stack by the second image"
" in the stack, using 2 \"complex\" images as its input - a \"complex\""
" image is one where channel 2*n is the real part of the nth channel and"
" channel 2*n + 1 is the imaginary part of the nth channel. Using zero"
" arguments results in a straight division (a + bi) / (c + di). Using"
" one argument results in a conjugate division (a - bi) / (c + di).\n"
"\n"
"Usage: ImageStack -load a.tga -load b.tga -complexdivide -save out.tga.\n");
}
void FFTConvolve::help() {
pprintf("-fftconvolve performs convolution in Fourier space. It is much faster"
" than -convolve for large kernels. The two arguments are the boundary"
" condition (zero, clamp, wrap, homogeneous) and the vector-vector"
" multiplication used (inner, outer, elementwise). The defaults are wrap"
" and outer respectively. See -convolve for a description of each"
" option.\n"
"\n"
"Usage: ImageStack -load filter.tmp -load im.jpg -fftconvolve zero inner\n");
}
void GPSSensorWriter::Write(Print *p) {
float lat;
float lon;
unsigned long age;
gps_->f_get_position(&lat, &lon, &age);
char buf[16]; // No %f in sprintf? What the f**k.
char buf2[16];
pprintf(p, "GPS: LAT: %s, LON: %s AGE: %lu\n", strf(buf, lat), strf(buf2, lon), age);
}
void PatchPCA::help() {
pprintf("-patchpca treats local Gaussian neighbourhoods of pixel values as vectors"
" and computes a stack of filters that can be used to reduce"
" dimensionality and decorrelate the color channels. The two arguments"
" are the standard deviation of the Gaussian, and the desired number of"
" output dimensions. Patches near the edge of the image are not"
" included in the covariance computation.\n"
"Usage: ImageStack -load a.jpg -patchpca 2 8 -save filters.tmp\n"
" -pull 1 -convolve zero inner -save reduced.tmp\n");
}
void print_node(PARAM_NODE *p_node, int ident)
{
switch(p_node->content_type) {
case NODE_CONSTANT_INT:
pprintf("%*cNODE_CONSTANT_INT(%d, 0x%x)",ident*2,' ',p_node->cint,p_node->cint);
break;
case NODE_CONSTANT_FLOAT:
pprintf("%*cNODE_CONSTANT_FLOAT(%d)",ident*2,' ',p_node->cfloat);
break;
default:
char *p_token_name = get_token_name(*p_node);
if(!p_token_name) {
p_token_name = (char *)"UNKNOWN NODE!";
assert(0);
}
pprintf("%*c%s",ident*2,' ',p_token_name);
break;
}
}
void Poisson::help() {
pprintf("-poisson assumes the stack contains gradients images in x and y, and"
" attempts to find the image which fits those gradients best in a least"
" squares sense. It uses a preconditioned conjugate gradient descent"
" method. It takes one argument, which is required RMS error of the"
" result. This defaults to 0.01 if not given.\n"
"\n"
"Usage: ImageStack -load dx.tmp dy.tmp \n"
" -poisson 0.0001 -save out.tga\n\n");
}
static int devices_proc(struct proc_file *pf, void *arg) {
dev_t devno;
struct dev *dev;
pprintf(pf, "devno name driver type unit\n");
pprintf(pf, "----- -------- ---------------- ------ ------------------------------\n");
for (devno = 0; devno < num_devs; devno++) {
dev = devtab[devno];
pprintf(pf, "%5d %-8s %-16s %-6s ", devno, dev->name, dev->driver->name, devtypenames[dev->driver->type]);
if (dev->unit) {
pprintf(pf, "%s unit %d.%d\n", busnames[dev->unit->bus->bustype], dev->unit->bus->busno, dev->unit->unitno);
} else {
pprintf(pf, "<none>\n");
}
}
return 0;
}
/*
* asethandle
*
* Usage: asethandle oldname newname
*
* This command changes the handle of the player from oldname to
* newname. The various player information, messages, logins, comments
* and games should be automatically transferred to the new account.
*/
int com_asethandle(int p, param_list param)
{
char *player = param[0].val.word;
char *newplayer = param[1].val.word;
char playerlower[MAX_LOGIN_NAME], newplayerlower[MAX_LOGIN_NAME];
int p1;
strcpy(playerlower, player);
stolower(playerlower);
strcpy(newplayerlower, newplayer);
stolower(newplayerlower);
if (player_find_bylogin(playerlower) >= 0) {
pprintf(p, "A player by that name is logged in.\n");
return COM_OK;
}
if (player_find_bylogin(newplayerlower) >= 0) {
pprintf(p, "A player by that new name is logged in.\n");
return COM_OK;
}
p1 = player_new();
if (player_read(p1, playerlower)) {
pprintf(p, "No player by the name %s is registered.\n", player);
player_remove(p1);
return COM_OK;
} else {
if (!check_admin2(p, p1)) {
pprintf(p, "You can't set handles for an admin with a level higher than or equal to yourself.\n");
player_remove(p1);
return COM_OK;
}
}
player_remove(p1);
p1 = player_new();
if ((!player_read(p1, newplayerlower)) && (strcmp(playerlower, newplayerlower))) {
pprintf(p, "Sorry that handle is already taken.\n");
player_remove(p1);
return COM_OK;
}
player_remove(p1);
if ((!player_rename(playerlower, newplayerlower)) && (!player_read(p1, newplayerlower))) {
pprintf(p, "Player %s renamed to %s.\n", player, newplayer);
free(player_globals.parray[p1].name);
player_globals.parray[p1].name = strdup(newplayer);
player_save(p1);
/*if (player_globals.parray[p1].s_stats.rating > 0)
UpdateRank(TYPE_STAND, newplayer, &player_globals.parray[p1].s_stats, player);
if (player_globals.parray[p1].z_stats.rating > 0)
UpdateRank(TYPE_CRAZYHOUSE, newplayer, &player_globals.parray[p1].z_stats, player);
if (player_globals.parray[p1].w_stats.rating > 0)
UpdateRank(TYPE_WILD, newplayer, &player_globals.parray[p1].w_stats, player);*/
} else {
pprintf(p, "Asethandle failed.\n");
}
player_remove(p1);
return COM_OK;
}
/*
force a server reload
*/
int com_areload(int p, param_list param)
{
extern unsigned chessd_reload_flag;
chessd_reload_flag = 1;
pprintf(p, "Server reload started\n");
return COM_OK;
}
void FFT::help() {
pprintf("-fft performs a fast dft on the current image, whose values"
" are interpreted as complex. The input is an image with 2*c channels,"
" where channel 2*i is the real part of the i\'th channel, and channel"
" 2*i+1 is the imaginary part of the i'th channel. The output image is"
" laid out the same way.\n"
"\n"
"Usage: ImageStack -load a.tmp -fftcomplex -save freq.tmp\n\n");
}
static int output_json_node_value (JsonNode *node,
PRN *prn)
{
GType type = 0;
int err = 0;
if (null_node(node)) {
gretl_errmsg_set("jsonget: got a null node");
return E_DATA;
}
type = json_node_get_value_type(node);
#if 0
fprintf(stderr, "jsonget: node type %s\n", g_type_name(type));
#endif
if (!handled_type(type)) {
gretl_errmsg_sprintf("jsonget: unhandled object type '%s'",
g_type_name(type));
err = E_DATA;
} else if (type == G_TYPE_STRING) {
const gchar *s = json_node_get_string(node);
if (s != NULL) {
pputs(prn, s);
} else {
err = E_DATA;
}
} else if (type == G_TYPE_DOUBLE) {
double x = json_node_get_double(node);
pprintf(prn, "%.15g", x);
} else {
gint64 k = json_node_get_int(node);
double x = (double) k;
pprintf(prn, "%.15g", x);
}
return err;
}
/*
* asetadmin
*
* Usage: asetadmin player AdminLevel
*
* Sets the admin level of the player with the following restrictions.
* 1. You can only set the admin level of players lower than yourself.
* 2. You can only set the admin level to a level that is lower than
* yourself.
*/
int com_asetadmin(int p, param_list param)
{
struct player *pp = &player_globals.parray[p];
int p1, connected, oldlevel;
if (!FindPlayer(p, param[0].val.word,&p1, &connected))
return COM_OK;
if (!check_admin2(p, p1)) {
pprintf(p, "You can only set adminlevel for players below your adminlevel.\n");
if (!connected)
player_remove(p1);
return COM_OK;
}
if (!strcmp(player_globals.parray[p1].login, pp->login)) {
pprintf(p, "You can't change your own adminlevel.\n");
return COM_OK;
}
if (!check_admin(p, param[1].val.integer+1)) {
pprintf(p, "You can't promote someone to or above your adminlevel.\n");
if (!connected)
player_remove(p1);
return COM_OK;
}
if (param[1].val.integer < 0)
{
pprintf(p, "Level must be positive.\n");
if (!connected)
player_remove(p1);
return COM_OK;
}
oldlevel = player_globals.parray[p1].adminLevel;
player_globals.parray[p1].adminLevel = param[1].val.integer;
pprintf(p, "Admin level of %s set to %d.\n", player_globals.parray[p1].name, player_globals.parray[p1].adminLevel);
player_save(p1);
if (connected) {
pprintf_prompt(p1, "\n\n%s has set your admin level to %d.\n\n", pp->name, player_globals.parray[p1].adminLevel);
} else {
player_remove(p1);
}
return COM_OK;
}
static int gui_parse_object_request (const char *line,
char *objname, char **param,
void **pptr, GretlObjType *type,
PRN *prn)
{
char word[MAXSAVENAME] = {0};
int action;
/* get object name (if any) and dot param */
parse_object_command(line, word, param);
/* if no dot param, nothing doing, pass through */
if (*param == NULL) {
return OBJ_ACTION_NONE;
}
if (gretl_is_bundle(word)) {
return OBJ_ACTION_NONE;
}
/* see if there's an object associated with the name */
*pptr = get_session_object_by_name(word, type);
if (*pptr == NULL) {
/* no matching object */
if (*param) {
pprintf(prn, _("%s: no such object\n"), word);
}
return OBJ_ACTION_INVALID;
}
action = match_object_command(*param);
if (action == OBJ_ACTION_INVALID) {
pprintf(prn, _("command '%s' not recognized"), *param);
pputc(prn, '\n');
} else {
strcpy(objname, word);
}
return action;
}
void ComplexMultiply::help() {
pprintf("-complexmultiply multiplies the top image in the stack by the second"
" image in the stack, using 2 \"complex\" images as its input - a"
" \"complex\" image is one where channel 2*n is the real part of the nth"
" channel and channel 2*n + 1 is the imaginary part of the nth"
" channel. Using zero arguments results in a straight multiplication"
" (a + bi) * (c + di), using one argument results in a conjugate"
" multiplication (a - bi) * (c + di).\n"
"\n"
"Usage: ImageStack -load a.tga -load b.tga -complexmultiply -save out.tga.\n");
}
void CreateTmp::help() {
pprintf("-createtmp creates a zero filled floating point .tmp file of the specified"
" dimensions. It can be used to create tmp files larger than can fit in"
" memory. The five arguments are the filename, width, height, frames and"
" channels. If only four arguments are specified, frames is assumed to"
" be one.\n\n"
"The following example creates a giant volume, and fills some of it with noise:\n"
"ImageStack -createtmp volume.tmp 1024 1024 1024 1 \\\n"
" -push 256 256 256 1 -noise \\\n"
" -saveblock volume.tmp 512 512 512 0 \n\n");
}
/*
* asetstd
*
* Usage: asetstd handle rating won lost drew RD
*
* This command allows admins to set a user's statistics for Standard games.
* The parameters are self-explanatory: rating, # of wins, # of losses, # of
* draws, and ratings deviation.
*/
int com_asetstd(int p, param_list param)
{
int p1, connected;
if (!FindPlayer(p, param[0].val.word, &p1, &connected))
return COM_OK;
if (CheckPFlag(p1, PFLAG_REG)) {
SetRating(p1, param, &player_globals.parray[p1].s_stats);
player_save(p1);
UpdateRank(TYPE_STAND, player_globals.parray[p1].name, &player_globals.parray[p1].s_stats,
player_globals.parray[p1].name);
pprintf(p, "Standard rating for %s modified.\n", player_globals.parray[p1].name);
} else
pprintf(p, "%s is unregistered. Can't modify rating.\n", player_globals.parray[p1].name);
if (!connected)
player_remove(p1);
return COM_OK;
}
static void tester3(long a0, void* a1){
int i = 0, ret;
char pbuffer[SBUFSZ];
pprintf("tester3 starts\n");
while (i < 1)
{
i ++;
/*
uthread_mtx_lock(&mtx1);
uthread_mtx_lock(&mtx3);
*/
pprintf("test3 about to broadcast\n");
uthread_cond_broadcast(&cond);
sprintf(pbuffer, "thread 3: broadcast ends\n");
ret = write(STDOUT_FILENO, pbuffer, strlen(pbuffer));
if (ret < 0)
{
perror("uthreads_test");
/* XXX: we should really cleanup here */
exit(1);
}
/*
uthread_mtx_unlock(&mtx1);
uthread_mtx_unlock(&mtx3);
*/
}
sprintf(pbuffer, "thread 3 exiting.\n");
ret = write(STDOUT_FILENO, pbuffer, strlen(pbuffer));
if (ret < 0)
{
perror("uthreads_test");
/* XXX: we should really cleanup here */
exit(1);
}
uthread_exit(a0);
}
