File: [local] / OpenXM_contrib / gnuplot / Attic / graphics.c (download)
Revision 1.1.1.2 (vendor branch), Sat Jan 22 14:15:57 2000 UTC (24 years, 3 months ago) by maekawa
Branch: GNUPLOT
CVS Tags: maekawa-ipv6, VERSION_3_7_1, RELEASE_20000124, RELEASE_1_2_2, RELEASE_1_2_1, RELEASE_1_1_3, RELEASE_1_1_2
Changes since 1.1.1.1: +90 -78
lines
Import gnuplot 3.7.1
|
#ifndef lint
static char *RCSid = "$Id: graphics.c,v 1.24.2.2 1999/09/15 15:30:29 lhecking Exp $";
#endif
/* GNUPLOT - graphics.c */
/*[
* Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
*
* Permission to use, copy, and distribute this software and its
* documentation for any purpose with or without fee is hereby granted,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.
*
* Permission to modify the software is granted, but not the right to
* distribute the complete modified source code. Modifications are to
* be distributed as patches to the released version. Permission to
* distribute binaries produced by compiling modified sources is granted,
* provided you
* 1. distribute the corresponding source modifications from the
* released version in the form of a patch file along with the binaries,
* 2. add special version identification to distinguish your version
* in addition to the base release version number,
* 3. provide your name and address as the primary contact for the
* support of your modified version, and
* 4. retain our contact information in regard to use of the base
* software.
* Permission to distribute the released version of the source code along
* with corresponding source modifications in the form of a patch file is
* granted with same provisions 2 through 4 for binary distributions.
*
* This software is provided "as is" without express or implied warranty
* to the extent permitted by applicable law.
]*/
#include "plot.h"
#include "setshow.h"
/* key placement is calculated in boundary, so we need file-wide variables
* To simplify adjustments to the key, we set all these once [depends on
* key_reverse] and use them throughout.
*/
/*{{{ local and global variables */
static int key_sample_width; /* width of line sample */
static int key_sample_left; /* offset from x for left of line sample */
static int key_sample_right; /* offset from x for right of line sample */
static int key_point_offset; /* offset from x for point sample */
static int key_text_left; /* offset from x for left-justified text */
static int key_text_right; /* offset from x for right-justified text */
static int key_size_left; /* size of left bit of key (text or sample, depends on key_reverse) */
static int key_size_right; /* size of right part of key (including padding) */
/* I think the following should also be static ?? */
static int key_xl, key_xr, key_yt, key_yb; /* boundarys for key field */
static int max_ptitl_len = 0; /* max length of plot-titles (keys) */
static int ktitl_lines = 0; /* no lines in key_title (key header) */
static int ptitl_cnt; /* count keys with len > 0 */
static int key_cols; /* no cols of keys */
static int key_rows, key_col_wth, yl_ref;
/* penalty for doing tics by callback in gen_tics is need for
* global variables to communicate with the tic routines
* Dont need to be arrays for this
*/
static int tic_start, tic_direction, tic_text, rotate_tics, tic_hjust, tic_vjust, tic_mirror;
/* set by tic_callback - how large to draw polar radii */
static double largest_polar_circle;
/* either xformat etc or invented time format
* index with FIRST_X_AXIS etc
* global because used in gen_tics, which graph3d also uses
*/
char ticfmt[8][MAX_ID_LEN+1]; /* HBB 990106: fix buffer overrun */
int timelevel[8];
double ticstep[8];
static int xlablin, x2lablin, ylablin, y2lablin, titlelin, xticlin, x2ticlin;
static int key_entry_height; /* bigger of t->v_size, pointsize*t->v_tick */
static int p_width, p_height; /* pointsize * { t->h_tic | t->v_tic } */
/* there are several things on right of plot - key, y2tics and y2label
* when working out boundary, save posn of y2label for later...
* Same goes for x2label.
* key posn is also stored in key_xl, and tics go at xright
*/
static int ylabel_x, y2label_x, xlabel_y, x2label_y, title_y, time_y, time_x;
static int ylabel_y, y2label_y, xtic_y, x2tic_y, ytic_x, y2tic_x;
/*}}} */
/*{{{ static fns and local macros */
static void plot_impulses __PROTO((struct curve_points * plot, int yaxis_x,
int xaxis_y));
static void plot_lines __PROTO((struct curve_points * plot));
static void plot_points __PROTO((struct curve_points * plot));
static void plot_dots __PROTO((struct curve_points * plot));
static void plot_bars __PROTO((struct curve_points * plot));
static void plot_boxes __PROTO((struct curve_points * plot, int xaxis_y));
static void plot_vectors __PROTO((struct curve_points * plot));
static void plot_f_bars __PROTO((struct curve_points * plot));
static void plot_c_bars __PROTO((struct curve_points * plot));
static void edge_intersect __PROTO((struct coordinate GPHUGE * points, int i,
double *ex, double *ey));
static int two_edge_intersect __PROTO((struct coordinate GPHUGE * points,
int i, double *lx, double *ly));
static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
static void plot_steps __PROTO((struct curve_points * plot)); /* JG */
static void plot_fsteps __PROTO((struct curve_points * plot)); /* HOE */
static void plot_histeps __PROTO((struct curve_points * plot)); /* CAC */
static void histeps_horizontal __PROTO((int *xl, int *yl, double x1, double x2,
double y)); /* CAC */
static void histeps_vertical __PROTO((int *xl, int *yl, double x, double y1,
double y2)); /* CAC */
static void edge_intersect_steps __PROTO((struct coordinate GPHUGE * points,
int i, double *ex, double *ey)); /* JG */
static void edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points,
int i, double *ex, double *ey)); /* HOE */
static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly)); /* JG */
static TBOOLEAN two_edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
static double LogScale __PROTO((double coord, int is_log, double log_base_log,
char *what, char *axis));
static double dbl_raise __PROTO((double x, int y));
static void boundary __PROTO((int scaling, struct curve_points * plots,
int count));
static double make_tics __PROTO((int axis, int guide));
/* widest2d_callback keeps longest so far in here */
static int widest_tic;
static void widest2d_callback __PROTO((int axis, double place, char *text,
struct lp_style_type grid));
static void ytick2d_callback __PROTO((int axis, double place, char *text,
struct lp_style_type grid));
static void xtick2d_callback __PROTO((int axis, double place, char *text,
struct lp_style_type grid));
static void map_position __PROTO((struct position * pos, unsigned int *x,
unsigned int *y, char *what));
static void mant_exp __PROTO((double log_base, double x, int scientific,
double *m, int *p));
static void gprintf __PROTO((char *dest, size_t count, char *format,
double log_base, double x));
#if defined(sun386) || defined(AMIGA_SC_6_1)
static double CheckLog __PROTO((TBOOLEAN is_log, double base_log, double x));
#endif
/* for plotting error bars
* half the width of error bar tic mark
*/
#define ERRORBARTIC (t->h_tic/2)
/*
* The Amiga SAS/C 6.2 compiler moans about macro envocations causing
* multiple calls to functions. I converted these macros to inline
* functions coping with the problem without loosing speed.
* If your compiler supports __inline, you should add it to the
* #ifdef directive
* (MGR, 1993)
*/
#ifdef AMIGA_SC_6_1
GP_INLINE static TBOOLEAN i_inrange(int z, int min, int max)
{
return ((min < max) ? ((z >= min) && (z <= max)) : ((z >= max) && (z <= min)));
}
GP_INLINE static double f_max(double a, double b)
{
return (GPMAX(a, b));
}
GP_INLINE static double f_min(double a, double b)
{
return (GPMIN(a, b));
}
#else
#define f_max(a,b) GPMAX((a),(b))
#define f_min(a,b) GPMIN((a),(b))
#define i_inrange(z,a,b) inrange((z),(a),(b))
#endif
/* True if a and b have the same sign or zero (positive or negative) */
#define samesign(a,b) ((a) * (b) >= 0)
/*}}} */
/*{{{ more variables */
/* Define the boundary of the plot
* These are computed at each call to do_plot, and are constant over
* the period of one do_plot. They actually only change when the term
* type changes and when the 'set size' factors change.
* - no longer true, for 'set key out' or 'set key under'. also depend
* on tic marks and multi-line labels.
* They are shared with graph3d.c since we want to use its draw_clip_line()
*/
int xleft, xright, ybot, ytop;
/* we make a local copy of the 'key' variable so that if something
* goes wrong, we can switch it off temporarily
*/
static int lkey;
/* First attempt at double axes...
* x_min etc are now accessed from a global array min_array[], max_array[]
* put the scale factors into a similar array
* for convenience in this first attack on double axes, just define x_min etc
* since code already uses x_min, etc Eventually it will be done properly
*/
extern double min_array[], max_array[];
extern int auto_array[];
extern int log_array[];
extern double base_array[], log_base_array[];
static int x_axis = FIRST_X_AXIS, y_axis = FIRST_Y_AXIS; /* current axes */
static double scale[AXIS_ARRAY_SIZE]; /* scale factors for mapping for each axis */
/* BODGES BEFORE I FIX IT UP */
#define x_min min_array[x_axis]
#define x_max max_array[x_axis]
#define y_min min_array[y_axis]
#define y_max max_array[y_axis]
/* And the functions to map from user to terminal coordinates */
/* maps floating point x to screen */
#define map_x(x) (int)(xleft+(x-min_array[x_axis])*scale[x_axis]+0.5)
/* same for y */
#define map_y(y) (int)(ybot +(y-min_array[y_axis])*scale[y_axis]+0.5)
/* (DFK) Watch for cancellation error near zero on axes labels */
/* less than one hundredth of a tic mark */
#define SIGNIF (0.01)
#define CheckZero(x,tic) (fabs(x) < ((tic) * SIGNIF) ? 0.0 : (x))
#define NearlyEqual(x,y,tic) (fabs((x)-(y)) < ((tic) * SIGNIF))
/*}}} */
/*{{{ CheckLog() */
/* (DFK) For some reason, the Sun386i compiler screws up with the CheckLog
* macro, so I write it as a function on that machine.
*
* Amiga SAS/C 6.2 thinks it will do too much work calling functions in
* macro arguments twice, thus I inline theese functions. (MGR, 1993)
* If your compiler doesn't handle those macros correctly, you should
* also subscribe here. Even without inlining you gain speed with log plots
*/
#if defined(sun386) || defined(AMIGA_SC_6_1)
GP_INLINE static double CheckLog(is_log, base_log, x)
TBOOLEAN is_log;
double base_log;
double x;
{
if (is_log)
return (pow(base_log, x));
else
return (x);
}
#else
/* (DFK) Use 10^x if logscale is in effect, else x */
#define CheckLog(is_log, base_log, x) ((is_log) ? pow(base_log, (x)) : (x))
#endif /* sun386 || SAS/C */
/*}}} */
/*{{{ LogScale() */
static double LogScale(coord, is_log, log_base_log, what, axis)
double coord; /* the value */
TBOOLEAN is_log; /* is this axis in logscale? */
double log_base_log; /* if so, the log of its base */
char *what; /* what is the coord for? */
char *axis; /* which axis is this for ("x" or "y")? */
{
if (is_log) {
if (coord <= 0.0) {
char errbuf[100]; /* place to write error message */
(void) sprintf(errbuf, "%s has %s coord of %g; must be above 0 for log scale!",
what, axis, coord);
graph_error(errbuf);
} else
return (log(coord) / log_base_log);
}
return (coord);
}
/*}}} */
/*{{{ graph_error() */
/* handle errors during graph-plot in a consistent way */
void graph_error(text)
char *text;
{
multiplot = FALSE;
term_end_plot();
int_error(text, NO_CARET);
}
/*}}} */
/*{{{ fixup_range() */
/*
* === SYNOPSIS ===
*
* This function checks whether the data and/or plot range in a given axis
* is too small (which would cause divide-by-zero and/or infinite-loop
* problems later on). If so,
* - if autoscaling is in effect for this axis, we widen the range
* - otherwise, we abort with a call to int_error() (which prints out
* a suitable error message, then (hopefully) aborts this command and
* returns to the command prompt or whatever).
*
*
* === HISTORY AND DESIGN NOTES ===
*
* 1998 Oct 4, Jonathan Thornburg <jthorn@galileo.thp.univie.ac.at>
*
* This function used to be a (long) macro FIXUP_RANGE(AXIS, WHICH)
* which was (identically!) defined in plot2d.c and plot3d.c . As
* well as now being a function instead of a macro, the logic is also
* changed: The "too small" range test no longer depends on 'set zero'
* and is now properly scaled relative to the data magnitude.
*
* The key question in designing this function is the policy for just how
* much to widen the data range by, as a function of the data magnitude.
* This is to some extent a matter of taste. IMHO the key criterion is
* that (at least) all of the following should (a) not infinite-loop, and
* (b) give correct plots, regardless of the 'set zero' setting:
* plot 6.02e23 # a huge number >> 1 / FP roundoff level
* plot 3 # a "reasonable-sized" number
* plot 1.23e-12 # a small number still > FP roundoff level
* plot 1.23e-12 * sin(x) # a small function still > FP roundoff level
* plot 1.23e-45 # a tiny number << FP roundoff level
* plot 1.23e-45 * sin(x) # a tiny function << FP roundoff level
* plot 0 # or (more commonly) a data file of all zeros
* That is, IMHO gnuplot should *never* infinite-loop, and it should *never*
* producing an incorrect or misleading plot. In contrast, the old code
* would infinite-loop on most of these examples with 'set zero 0.0' in
* effect, or would plot the small-amplitude sine waves as the zero function
* with 'zero' set larger than the sine waves' amplitude.
*
* The current code plots all the above examples correctly and without
* infinite looping.
*
*
* === USAGE ===
*
* Arguments:
* axis = (in) An integer specifying which axis (x1, x2, y1, y2, z, etc)
* we should do our stuff for. We use this argument as an
* index into the global arrays {min,max,auto}_array . In
* practice this argument will typically be one of the constants
* {FIRST,SECOND}_{X,Y,Z}_AXIS defined in plot.h.
* axis_name --> (in) This argument should point to the character string
* name corresponding to axis , e.g. "x", "y2", etc.
* We use this (only) in formatting warning/error messages.
*
* Global Variables:
* auto_array[axis] = (in) (defined in command.c) Bit-flags which tell
* [in some manner I don't fully understand :=( ]
* whether and/or how autoscaling is in effect for
* this axis.
* {min,max}_array = (in out) (defined in command.c) The data ranges which
* this function manipulates.
* c_token = (in) (defined in plot.h) Used in formatting an error message.
*
* Bugs:
* - If strlen(axis_name) > strlen("%s") , we may overflow an
* error-message buffer, which would be A Bad Thing. Caveat caller...
*/
void fixup_range(axis, axis_name)
int axis;
char *axis_name;
{
#define MAX_AXIS_NAME_LEN 2 /* max legal strlen(axis_name) */
/* These two macro definitions set the range-widening policy: */
#define FIXUP_RANGE__WIDEN_ZERO_ABS 1.0 /* widen [0:0] by
+/- this absolute amount */
#define FIXUP_RANGE__WIDEN_NONZERO_REL 0.01 /* widen [nonzero:nonzero] by
-/+ this relative amount */
double dmin = min_array[axis];
double dmax = max_array[axis];
if (dmax - dmin == 0.0) {
/* empty range */
if (auto_array[axis]) {
/* range came from autoscaling ==> widen it */
double widen = (dmax == 0.0)
? FIXUP_RANGE__WIDEN_ZERO_ABS
: FIXUP_RANGE__WIDEN_NONZERO_REL * dmax;
fprintf(stderr,
"Warning: empty %s range [%g:%g], ",
axis_name, dmin, dmax);
min_array[axis] -= widen;
max_array[axis] += widen;
fprintf(stderr,
"adjusting to [%g:%g]\n",
min_array[axis], max_array[axis]);
} else {
/* user has explicitly set the range */
/* (to something empty) ==> we're in trouble */
char msg_buffer[MAX_LINE_LEN + 1];
sprintf(msg_buffer, "Can't plot with an empty %s range!", axis_name);
int_error(msg_buffer, c_token); /* never returns */
}
}
}
/*}}} */
/*{{{ widest2d_callback() */
/* we determine widest tick label by getting gen_ticks to call this
* routine with every label
*/
static void widest2d_callback(axis, place, text, grid)
int axis;
double place;
char *text;
struct lp_style_type grid;
{
int len = label_width(text, NULL);
if (len > widest_tic)
widest_tic = len;
}
/*}}} */
/*{{{ boundary() */
/* borders of plotting area
* computed once on every call to do_plot
*
* The order in which things is done is getting pretty critical:
* ytop depends on title, x2label, ylabels (if no rotated text)
* ybot depends on key, if TUNDER
* once we have these, we can setup the y1 and y2 tics and the
* only then can we calculate xleft and xright
* xright depends also on key TRIGHT
* then we can do x and x2 tics
*
* For set size ratio ..., everything depends on everything else...
* not really a lot we can do about that, so we lose if the plot has to
* be reduced vertically. But the chances are the
* change will not be very big, so the number of tics will not
* change dramatically.
*
* Margin computation redone by Dick Crawford (rccrawford@lanl.gov) 4/98
*/
static void boundary(scaling, plots, count)
TBOOLEAN scaling; /* TRUE if terminal is doing the scaling */
struct curve_points *plots;
int count;
{
int ytlen;
int yticlin = 0, y2ticlin = 0, timelin = 0;
register struct termentry *t = term;
int key_h, key_w;
int can_rotate = (*t->text_angle) (1);
int xtic_textheight; /* height of xtic labels */
int x2tic_textheight; /* height of x2tic labels */
int title_textheight; /* height of title */
int xlabel_textheight; /* height of xlabel */
int x2label_textheight; /* height of x2label */
int timetop_textheight; /* height of timestamp (if at top) */
int timebot_textheight; /* height of timestamp (if at bottom) */
int ylabel_textheight; /* height of (unrotated) ylabel */
int y2label_textheight; /* height of (unrotated) y2label */
int ylabel_textwidth; /* width of (rotated) ylabel */
int y2label_textwidth; /* width of (rotated) y2label */
int timelabel_textwidth; /* width of timestamp */
int ytic_textwidth; /* width of ytic labels */
int y2tic_textwidth; /* width of y2tic labels */
int x2tic_height; /* 0 for tic_in or no x2tics, ticscale*v_tic otherwise */
int xtic_height;
int ytic_width;
int y2tic_width;
/* figure out which rotatable items are to be rotated
* (ylabel and y2label are rotated if possible) */
int vertical_timelabel = can_rotate && timelabel_rotate;
int vertical_xtics = can_rotate && rotate_xtics;
int vertical_x2tics = can_rotate && rotate_x2tics;
int vertical_ytics = can_rotate && rotate_ytics;
int vertical_y2tics = can_rotate && rotate_y2tics;
lkey = key; /* but we may have to disable it later */
xticlin = ylablin = y2lablin = xlablin = x2lablin = titlelin = 0;
/*{{{ count lines in labels and tics */
if (*title.text)
label_width(title.text, &titlelin);
if (*xlabel.text)
label_width(xlabel.text, &xlablin);
if (*x2label.text)
label_width(x2label.text, &x2lablin);
if (*ylabel.text)
label_width(ylabel.text, &ylablin);
if (*y2label.text)
label_width(y2label.text, &y2lablin);
if (xtics)
label_width(xformat, &xticlin);
if (x2tics)
label_width(x2format, &x2ticlin);
if (ytics)
label_width(yformat, &yticlin);
if (y2tics)
label_width(y2format, &y2ticlin);
if (*timelabel.text)
label_width(timelabel.text, &timelin);
/*}}} */
/*{{{ preliminary ytop calculation */
/* first compute heights of things to be written in the margin */
/* title */
if (titlelin)
title_textheight = (int) ((titlelin + title.yoffset + 1) * (t->v_char));
else
title_textheight = 0;
/* x2label */
if (x2lablin) {
x2label_textheight = (int) ((x2lablin + x2label.yoffset) * (t->v_char));
if (!x2tics)
x2label_textheight += 0.5 * t->v_char;
} else
x2label_textheight = 0;
/* tic labels */
if (x2tics & TICS_ON_BORDER) {
/* ought to consider tics on axes if axis near border */
if (vertical_x2tics) {
/* guess at tic length, since we don't know it yet
--- we'll fix it after the tic labels have been created */
x2tic_textheight = (int) (5 * (t->h_char));
} else
x2tic_textheight = (int) ((x2ticlin) * (t->v_char));
} else
x2tic_textheight = 0;
/* tics */
if (!tic_in && ((x2tics & TICS_ON_BORDER) || ((xtics & TICS_MIRROR) && (xtics & TICS_ON_BORDER))))
x2tic_height = (int) ((t->v_tic) * ticscale);
else
x2tic_height = 0;
/* timestamp */
if (*timelabel.text && !timelabel_bottom)
timetop_textheight = (int) ((timelin + timelabel.yoffset + 2) * (t->v_char));
else
timetop_textheight = 0;
/* horizontal ylabel */
if (*ylabel.text && !can_rotate)
ylabel_textheight = (int) ((ylablin + ylabel.yoffset) * (t->v_char));
else
ylabel_textheight = 0;
/* horizontal y2label */
if (*y2label.text && !can_rotate)
y2label_textheight = (int) ((y2lablin + y2label.yoffset) * (t->v_char));
else
y2label_textheight = 0;
/* compute ytop from the various components
* unless tmargin is explicitly specified */
ytop = (int) ((ysize + yoffset) * (t->ymax));
if (tmargin < 0) {
int top_margin = x2label_textheight + title_textheight;
if (timetop_textheight + ylabel_textheight > top_margin)
top_margin = timetop_textheight + ylabel_textheight;
if (y2label_textheight > top_margin)
top_margin = y2label_textheight;
top_margin += x2tic_height + x2tic_textheight;
/* x2tic_height and x2tic_textheight are computed as only the
* relevant heights, but they nonetheless need a blank
* space above them */
if (top_margin > x2tic_height)
top_margin += (int) (t->v_char);
ytop -= top_margin;
if (ytop == (int) (0.5 + (ysize + yoffset) * (t->ymax))) {
/* make room for the end of rotated ytics or y2tics */
ytop -= (int) ((t->h_char) * 2);
}
} else
ytop -= (int) ((t->v_char) * tmargin);
/* end of preliminary ytop calculation }}} */
/*{{{ tentative xleft, needed for TUNDER */
if (lmargin >= 0)
xleft = (int) (xoffset * (t->xmax) + (t->h_char) * lmargin);
else
xleft = (int) (xoffset * (t->xmax) + (t->h_char) * 2);
/*}}} */
/*{{{ tentative xright, needed for TUNDER */
if (rmargin >= 0)
xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * rmargin);
else
xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * 2);
/*}}} */
/*{{{ preliminary ybot calculation
* first compute heights of labels and tics */
/* tic labels */
if (xtics & TICS_ON_BORDER) {
/* ought to consider tics on axes if axis near border */
if (vertical_xtics) {
/* guess at tic length, since we don't know it yet */
xtic_textheight = (int) ((t->h_char) * 5);
} else
xtic_textheight = (int) ((t->v_char) * (xticlin + 1));
} else
xtic_textheight = 0;
/* tics */
if (!tic_in && ((xtics & TICS_ON_BORDER) || ((x2tics & TICS_MIRROR) && (x2tics & TICS_ON_BORDER))))
xtic_height = (int) ((t->v_tic) * ticscale);
else
xtic_height = 0;
/* xlabel */
if (xlablin) {
/* offset is subtracted because if > 0, the margin is smaller */
xlabel_textheight = (int) ((xlablin - xlabel.yoffset) * (t->v_char));
if (!xtics)
xlabel_textheight += 0.5 * t->v_char;
} else
xlabel_textheight = 0;
/* timestamp */
if (*timelabel.text && timelabel_bottom) {
/* && !vertical_timelabel)
* DBT 11-18-98 resize plot for vertical timelabels too !
*/
/* offset is subtracted because if . 0, the margin is smaller */
timebot_textheight = (int) ((timelin - timelabel.yoffset) * (t->v_char));
} else
timebot_textheight = 0;
/* compute ybot from the various components
* unless bmargin is explicitly specified */
ybot = (int) ((t->ymax) * yoffset);
if (bmargin < 0) {
ybot += xtic_height + xtic_textheight;
if (xlabel_textheight > 0)
ybot += xlabel_textheight;
if (timebot_textheight > 0)
ybot += timebot_textheight;
/* HBB 19990616: round to nearest integer, required to escape
* floating point inaccuracies */
if (ybot == (int)(0.5 + (t->ymax) * yoffset)) {
/* make room for the end of rotated ytics or y2tics */
ybot += (int) ((t->h_char) * 2);
}
} else
ybot += (int) (bmargin * (t->v_char));
/* end of preliminary ybot calculation }}} */
#define KEY_PANIC(x) if (x) { lkey = 0; goto key_escape; }
if (lkey) {
/*{{{ essential key features */
p_width = pointsize * t->h_tic;
p_height = pointsize * t->v_tic;
if (key_swidth >= 0)
key_sample_width = key_swidth * (t->h_char) + p_width;
else
key_sample_width = 0;
key_entry_height = p_height * 1.25 * key_vert_factor;
if (key_entry_height < (t->v_char))
key_entry_height = (t->v_char) * key_vert_factor;
/* count max_len key and number keys with len > 0 */
max_ptitl_len = find_maxl_keys(plots, count, &ptitl_cnt);
if ((ytlen = label_width(key_title, &ktitl_lines)) > max_ptitl_len)
max_ptitl_len = ytlen;
if (key_reverse) {
key_sample_left = -key_sample_width;
key_sample_right = 0;
/* if key width is being used, adjust right-justified text */
key_text_left = t->h_char;
key_text_right = (t->h_char) * (max_ptitl_len + 1 + key_width_fix);
key_size_left = t->h_char - key_sample_left; /* sample left is -ve */
key_size_right = key_text_right;
} else {
key_sample_left = 0;
key_sample_right = key_sample_width;
/* if key width is being used, adjust left-justified text */
key_text_left = -(int) ((t->h_char) * (max_ptitl_len + 1 + key_width_fix));
key_text_right = -(int) (t->h_char);
key_size_left = -key_text_left;
key_size_right = key_sample_right + t->h_char;
}
key_point_offset = (key_sample_left + key_sample_right) / 2;
/* advance width for cols */
key_col_wth = key_size_left + key_size_right;
key_rows = ptitl_cnt;
key_cols = 1;
/* calculate rows and cols for key - if something goes wrong,
* the tidiest way out is to set lkey = 0, and a goto
*/
if (lkey == -1) {
if (key_vpos == TUNDER) {
/* maximise no cols, limited by label-length */
key_cols = (int) (xright - xleft) / key_col_wth;
KEY_PANIC(key_cols == 0);
key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
KEY_PANIC(key_rows == 0);
/* now calculate actual no cols depending on no rows */
key_cols = (int) (ptitl_cnt + key_rows - 1) / key_rows;
KEY_PANIC(key_cols == 0);
key_col_wth = (int) (xright - xleft) / key_cols;
/* we divide into columns, then centre in column by considering
* ratio of * key_left_size to key_right_size
*
* key_size_left/(key_size_left+key_size_right) * (xright-xleft)/key_cols
* do one integer division to maximise accuracy (hope we
* don't overflow !)
*/
key_xl = xleft - key_size_left + ((xright - xleft) * key_size_left) / (key_cols * (key_size_left + key_size_right));
key_xr = key_xl + key_col_wth * (key_cols - 1) + key_size_left + key_size_right;
key_yb = t->ymax * yoffset;
key_yt = key_yb + key_rows * key_entry_height + ktitl_lines * t->v_char;
ybot += key_entry_height * key_rows + (int) ((t->v_char) * (ktitl_lines + 1));
} else {
/* maximise no rows, limited by ytop-ybot */
int i = (int) (ytop - ybot - (ktitl_lines + 1) * (t->v_char)) / key_entry_height;
KEY_PANIC(i == 0);
if (ptitl_cnt > i) {
key_cols = (int) (ptitl_cnt + i - 1) / i;
/* now calculate actual no rows depending on no cols */
KEY_PANIC(key_cols == 0);
key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
}
}
/* come here if we detect a division by zero in key calculations */
key_escape:
; /* ansi requires this */
}
/*}}} */
}
/*{{{ set up y and y2 tics */
{
/* setup_tics allows max number of tics to be specified
* but users dont like it to change with size and font,
* so we use value of 20, which is 3.5 behaviour.
* Note also that if format is '', yticlin = 0, so this gives
* division by zero.
* int guide = (ytop-ybot)/term->v_char;
*/
if (ytics)
setup_tics(FIRST_Y_AXIS, &yticdef, yformat, 20 /*(int) (guide/yticlin) */ );
if (y2tics)
setup_tics(SECOND_Y_AXIS, &y2ticdef, y2format, 20 /*(int) (guide/y2ticlin) */ );
}
/*}}} */
/*{{{ recompute xleft based on widths of ytics, ylabel etc
unless it has been explicitly set by lmargin */
/* tic labels */
if (ytics & TICS_ON_BORDER) {
if (vertical_ytics)
/* HBB: we will later add some white space as part of this, so
* reserve two more rows (one above, one below the text ...).
* Same will be done to similar calc.'s elsewhere */
ytic_textwidth = (int) ((t->v_char) * (yticlin + 2));
else {
widest_tic = 0; /* reset the global variable ... */
/* get gen_tics to call widest2d_callback with all labels
* the latter sets widest_tic to the length of the widest one
* ought to consider tics on axis if axis near border...
*/
gen_tics(FIRST_Y_AXIS, &yticdef, 0, 0, 0.0, widest2d_callback);
ytic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
}
} else {
ytic_textwidth = 0;
}
/* tics */
if (!tic_in && ((ytics & TICS_ON_BORDER) || ((y2tics & TICS_MIRROR) && (y2tics & TICS_ON_BORDER))))
ytic_width = (int) ((t->h_tic) * ticscale);
else
ytic_width = 0;
/* ylabel */
if (*ylabel.text && can_rotate) {
ylabel_textwidth = (int) ((ylablin - ylabel.xoffset) * (t->v_char));
if (!ytics)
ylabel_textwidth += 0.5 * t->v_char;
}
/* this should get large for NEGATIVE ylabel.xoffsets DBT 11-5-98 */
else
ylabel_textwidth = 0;
/* timestamp */
if (*timelabel.text && vertical_timelabel)
timelabel_textwidth = (int) ((timelin - timelabel.xoffset + 1.5) * (t->v_char));
else
timelabel_textwidth = 0;
/* compute xleft from the various components
* unless lmargin is explicitly specified */
xleft = (int) ((t->xmax) * xoffset);
if (lmargin < 0) {
xleft += (timelabel_textwidth > ylabel_textwidth ? timelabel_textwidth : ylabel_textwidth)
+ ytic_width + ytic_textwidth;
/* make sure xleft is wide enough for a negatively
* x-offset horizontal timestamp
*/
if (!vertical_timelabel && xleft - ytic_width - ytic_textwidth < -(int) (timelabel.xoffset * (t->h_char)))
xleft = ytic_width + ytic_textwidth - (int) (timelabel.xoffset * (t->h_char));
if (xleft == (int)(0.5 + (t->xmax) * xoffset)) {
/* make room for end of xtic or x2tic label */
xleft += (int) ((t->h_char) * 2);
}
/* DBT 12-3-98 extra margin just in case */
xleft += 0.5 * t->v_char;
} else
xleft += (int) (lmargin * (t->h_char));
/* end of xleft calculation }}} */
/*{{{ recompute xright based on widest y2tic. y2labels, key TOUT
unless it has been explicitly set by rmargin */
/* tic labels */
if (y2tics & TICS_ON_BORDER) {
if (vertical_y2tics)
y2tic_textwidth = (int) ((t->v_char) * (y2ticlin + 2));
else {
widest_tic = 0; /* reset the global variable ... */
/* get gen_tics to call widest2d_callback with all labels
* the latter sets widest_tic to the length of the widest one
* ought to consider tics on axis if axis near border...
*/
gen_tics(SECOND_Y_AXIS, &y2ticdef, 0, 0, 0.0, widest2d_callback);
y2tic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
}
} else {
y2tic_textwidth = 0;
}
/* tics */
if (!tic_in && ((y2tics & TICS_ON_BORDER) || ((ytics & TICS_MIRROR) && (ytics & TICS_ON_BORDER))))
y2tic_width = (int) ((t->h_tic) * ticscale);
else
y2tic_width = 0;
/* y2label */
if (can_rotate && *y2label.text) {
y2label_textwidth = (int) ((y2lablin + y2label.xoffset) * (t->v_char));
if (!y2tics)
y2label_textwidth += 0.5 * t->v_char;
} else
y2label_textwidth = 0;
/* compute xright from the various components
* unless rmargin is explicitly specified */
xright = (int) ((t->xmax) * (xsize + xoffset));
if (rmargin < 0) {
/* xright -= y2label_textwidth + y2tic_width + y2tic_textwidth; */
xright -= y2tic_width + y2tic_textwidth;
if (y2label_textwidth > 0)
xright -= y2label_textwidth;
/* adjust for outside key */
if (lkey == -1 && key_hpos == TOUT) {
xright -= key_col_wth * key_cols;
key_xl = xright + (int) (t->h_tic);
}
if (xright == (int)(0.5 + (t->xmax) * (xsize + xoffset))) {
/* make room for end of xtic or x2tic label */
xright -= (int) ((t->h_char) * 2);
}
xright -= 0.5 * t->v_char; /* DBT 12-3-98 extra margin just in case */
} else
xright -= (int) (rmargin * (t->h_char));
/* end of xright calculation }}} */
if (aspect_ratio != 0.0) {
double current_aspect_ratio;
if (aspect_ratio < 0 && (max_array[x_axis] - min_array[x_axis]) != 0.0) {
current_aspect_ratio = -aspect_ratio * fabs((max_array[y_axis] - min_array[y_axis]) / (max_array[x_axis] - min_array[x_axis]));
} else
current_aspect_ratio = aspect_ratio;
/*{{{ set aspect ratio if valid and sensible */
if (current_aspect_ratio >= 0.01 && current_aspect_ratio <= 100.0) {
double current = ((double) (ytop - ybot)) / ((double) (xright - xleft));
double required = (current_aspect_ratio * (double) t->v_tic) / ((double) t->h_tic);
if (current > required) {
/* too tall */
ytop = ybot + required * (xright - xleft);
} else {
xright = xleft + (ytop - ybot) / required;
}
}
/*}}} */
}
/*{{{ set up x and x2 tics */
/* we should base the guide on the width of the xtics, but we cannot
* use widest_tics until tics are set up. Bit of a downer - let us
* assume tics are 5 characters wide
*/
{
/* see equivalent code for ytics above
* int guide = (xright - xleft) / (5*t->h_char);
*/
if (xtics)
setup_tics(FIRST_X_AXIS, &xticdef, xformat, 20 /*guide */ );
if (x2tics)
setup_tics(SECOND_X_AXIS, &x2ticdef, x2format, 20 /*guide */ );
}
/*}}} */
/* adjust top and bottom margins for tic label rotation */
if (tmargin < 0 && x2tics & TICS_ON_BORDER && vertical_x2tics) {
widest_tic = 0; /* reset the global variable ... */
gen_tics(SECOND_X_AXIS, &x2ticdef, 0, 0, 0.0, widest2d_callback);
ytop += x2tic_textheight;
/* Now compute a new one and use that instead: */
x2tic_textheight = (int) ((t->h_char) * (widest_tic));
ytop -= x2tic_textheight;
}
if (bmargin < 0 && xtics & TICS_ON_BORDER && vertical_xtics) {
widest_tic = 0; /* reset the global variable ... */
gen_tics(FIRST_X_AXIS, &xticdef, 0, 0, 0.0, widest2d_callback);
ybot -= xtic_textheight;
xtic_textheight = (int) ((t->h_char) * widest_tic);
ybot += xtic_textheight;
}
/* compute coordinates for axis labels, title et al
* (some of these may not be used) */
x2label_y = ytop + x2tic_height + x2tic_textheight + x2label_textheight;
if (x2tic_textheight && (title_textheight || x2label_textheight))
x2label_y += t->v_char;
title_y = x2label_y + title_textheight;
ylabel_y = ytop + x2tic_height + x2tic_textheight + ylabel_textheight;
y2label_y = ytop + x2tic_height + x2tic_textheight + y2label_textheight;
xlabel_y = ybot - xtic_height - xtic_textheight - xlabel_textheight + xlablin*(t->v_char);
ylabel_x = xleft - ytic_width - ytic_textwidth;
if (*ylabel.text && can_rotate)
ylabel_x -= ylabel_textwidth;
y2label_x = xright + y2tic_width + y2tic_textwidth;
if (*y2label.text && can_rotate)
y2label_x += y2label_textwidth - y2lablin * t->v_char;
if (vertical_timelabel) {
if (timelabel_bottom)
time_y = xlabel_y - timebot_textheight + xlabel_textheight;
else {
time_y = title_y + timetop_textheight - title_textheight - x2label_textheight;
}
} else {
if (timelabel_bottom)
time_y = ybot - xtic_height - xtic_textheight - xlabel_textheight - timebot_textheight + t->v_char;
else if (ylabel_textheight > 0)
time_y = ylabel_y + timetop_textheight;
else
time_y = ytop + x2tic_height + x2tic_textheight + timetop_textheight + (int) (t->h_char);
}
if (vertical_timelabel)
time_x = xleft - ytic_width - ytic_textwidth - timelabel_textwidth;
else
time_x = xleft - ytic_width - ytic_textwidth + (int) (timelabel.xoffset * (t->h_char));
xtic_y = ybot - xtic_height - (vertical_xtics ? (int) (t->h_char) : (int) (t->v_char));
x2tic_y = ytop + x2tic_height + (vertical_x2tics ? (int) (t->h_char) : x2tic_textheight);
ytic_x = xleft - ytic_width - (vertical_ytics ? (ytic_textwidth - (int) t->v_char) : (int) (t->h_char));
y2tic_x = xright + y2tic_width + (vertical_y2tics ? (int) (t->v_char) : (int) (t->h_char));
/* restore text to horizontal [we tested rotation above] */
(void) (*t->text_angle) (0);
/* needed for map_position() below */
scale[FIRST_Y_AXIS] = (ytop - ybot) / (max_array[FIRST_Y_AXIS] - min_array[FIRST_Y_AXIS]);
scale[FIRST_X_AXIS] = (xright - xleft) / (max_array[FIRST_X_AXIS] - min_array[FIRST_X_AXIS]);
scale[SECOND_Y_AXIS] = (ytop - ybot) / (max_array[SECOND_Y_AXIS] - min_array[SECOND_Y_AXIS]);
scale[SECOND_X_AXIS] = (xright - xleft) / (max_array[SECOND_X_AXIS] - min_array[SECOND_X_AXIS]);
/*{{{ calculate the window in the grid for the key */
if (lkey == 1 || (lkey == -1 && key_vpos != TUNDER)) {
/* calculate space for keys to prevent grid overwrite the keys */
/* do it even if there is no grid, as do_plot will use these to position key */
key_w = key_col_wth * key_cols;
key_h = (ktitl_lines) * t->v_char + key_rows * key_entry_height;
if (lkey == -1) {
if (key_vpos == TTOP) {
key_yt = (int) ytop - (t->v_tic);
key_yb = key_yt - key_h;
} else {
key_yb = ybot + (t->v_tic);
key_yt = key_yb + key_h;
}
if (key_hpos == TLEFT) {
key_xl = xleft + (t->h_char); /* for Left just */
key_xr = key_xl + key_w;
} else if (key_hpos == TRIGHT) {
key_xr = xright - (t->h_char); /* for Right just */
key_xl = key_xr - key_w;
} else { /* TOUT */
/* do this here for do_plot() */
/* align right first since rmargin may be manual */
key_xr = (xsize + xoffset) * (t->xmax) - (t->h_char);
key_xl = key_xr - key_w;
}
} else {
unsigned int x, y;
map_position(&key_user_pos, &x, &y, "key");
key_xl = x - key_size_left;
key_xr = key_xl + key_w;
key_yt = y + (ktitl_lines ? t->v_char : key_entry_height) / 2;
key_yb = key_yt - key_h;
}
}
/*}}} */
}
/*}}} */
/*{{{ dbl_raise() */
static double dbl_raise(x, y)
double x;
int y;
{
register int i = abs(y);
double val = 1.0;
while (--i >= 0)
val *= x;
if (y < 0)
return (1.0 / val);
return (val);
}
/*}}} */
/*{{{ timetic_fmt() */
void timetic_format(axis, amin, amax)
int axis;
double amin, amax;
{
struct tm tmin, tmax;
*ticfmt[axis] = 0; /* make sure we strcat to empty string */
ggmtime(&tmin, (double) time_tic_just(timelevel[axis], amin));
ggmtime(&tmax, (double) time_tic_just(timelevel[axis], amax));
/*
if ( tmax.tm_year == tmin.tm_year &&
tmax.tm_mon == tmin.tm_mon &&
tmax.tm_mday == tmin.tm_mday ) {
*/
if (tmax.tm_year == tmin.tm_year &&
tmax.tm_yday == tmin.tm_yday) {
/* same day, skip date */
if (tmax.tm_hour != tmin.tm_hour) {
strcpy(ticfmt[axis], "%H");
}
if (timelevel[axis] < 3) {
if (strlen(ticfmt[axis]))
strcat(ticfmt[axis], ":");
strcat(ticfmt[axis], "%M");
}
if (timelevel[axis] < 2) {
strcat(ticfmt[axis], ":%S");
}
} else {
if (tmax.tm_year != tmin.tm_year) {
/* different years, include year in ticlabel */
/* check convention, day/month or month/day */
if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
strcpy(ticfmt[axis], "%m/%d/%");
} else {
strcpy(ticfmt[axis], "%d/%m/%");
}
if (((int) (tmax.tm_year / 100)) != ((int) (tmin.tm_year / 100))) {
strcat(ticfmt[axis], "Y");
} else {
strcat(ticfmt[axis], "y");
}
} else {
if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
strcpy(ticfmt[axis], "%m/%d");
} else {
strcpy(ticfmt[axis], "%d/%m");
}
}
if (timelevel[axis] < 4) {
strcat(ticfmt[axis], "\n%H:%M");
}
}
}
/*}}} */
/*{{{ set_tic() */
/* the guide parameter was intended to allow the number of tics
* to depend on the relative sizes of the plot and the font.
* It is the approximate upper limit on number of tics allowed.
* But it did not go down well with the users.
* A value of 20 gives the same behaviour as 3.5, so that is
* hardwired into the calls to here. Maybe we will restore it
* to the automatic calculation one day
*/
double set_tic(l10, guide)
double l10;
int guide;
{
double xnorm, tics, posns;
int fl = (int) floor(l10);
xnorm = pow(10.0, l10 - fl); /* approx number of decades */
posns = guide / xnorm; /* approx number of tic posns per decade */
if (posns > 40)
tics = 0.05; /* eg 0, .05, .10, ... */
else if (posns > 20)
tics = 0.1; /* eg 0, .1, .2, ... */
else if (posns > 10)
tics = 0.2; /* eg 0,0.2,0.4,... */
else if (posns > 4)
tics = 0.5; /* 0,0.5,1, */
else if (posns > 1)
tics = 1; /* 0,1,2,.... */
else if (posns > 0.5)
tics = 2; /* 0, 2, 4, 6 */
else
/* getting desperate... the ceil is to make sure we
* go over rather than under - eg plot [-10:10] x*x
* gives a range of about 99.999 - tics=xnorm gives
* tics at 0, 99.99 and 109.98 - BAD !
* This way, inaccuracy the other way will round
* up (eg 0->100.0001 => tics at 0 and 101
* I think latter is better than former
*/
tics = ceil(xnorm);
return (tics * dbl_raise(10.0, fl));
}
/*}}} */
/*{{{ make_tics() */
static double make_tics(axis, guide)
int axis, guide;
{
register double xr, tic, l10;
xr = fabs(min_array[axis] - max_array[axis]);
l10 = log10(xr);
tic = set_tic(l10, guide);
if (log_array[axis] && tic < 1.0)
tic = 1.0;
if (datatype[axis] == TIME) {
struct tm ftm, etm;
/* this is not fun */
ggmtime(&ftm, (double) min_array[axis]);
ggmtime(&etm, (double) max_array[axis]);
timelevel[axis] = 0; /* seconds */
if (tic > 20) {
/* turn tic into units of minutes */
tic = set_tic(log10(xr / 60.0), guide) * 60;
timelevel[axis] = 1; /* minutes */
}
if (tic > 20 * 60) {
/* turn tic into units of hours */
tic = set_tic(log10(xr / 3600.0), guide) * 3600;
timelevel[axis] = 2; /* hours */
}
if (tic > 2 * 3600) {
/* need some tickling */
tic = set_tic(log10(xr / (3 * 3600.0)), guide) * 3 * 3600;
}
if (tic > 6 * 3600) {
/* turn tic into units of days */
tic = set_tic(log10(xr / DAY_SEC), guide) * DAY_SEC;
timelevel[axis] = 3; /* days */
}
if (tic > 3 * DAY_SEC) {
/* turn tic into units of weeks */
tic = set_tic(log10(xr / WEEK_SEC), guide) * WEEK_SEC;
if (tic < WEEK_SEC) { /* force */
tic = WEEK_SEC;
}
timelevel[axis] = 4; /* weeks */
}
if (tic > 3 * WEEK_SEC) {
/* turn tic into units of month */
tic = set_tic(log10(xr / MON_SEC), guide) * MON_SEC;
if (tic < MON_SEC) { /* force */
tic = MON_SEC;
}
timelevel[axis] = 5; /* month */
}
if (tic > 2 * MON_SEC) {
/* turn tic into units of month */
tic = set_tic(log10(xr / (3 * MON_SEC)), guide) * 3 * MON_SEC;
}
if (tic > 6 * MON_SEC) {
/* turn tic into units of years */
tic = set_tic(log10(xr / YEAR_SEC), guide) * YEAR_SEC;
if (tic < (YEAR_SEC / 2)) {
tic = YEAR_SEC / 2;
}
timelevel[axis] = 6; /* year */
}
}
return (tic);
}
/*}}} */
void do_plot(plots, pcount)
struct curve_points *plots;
int pcount; /* count of plots in linked list */
{
/* BODGES BEFORE I FIX IT UP */
#define ytic ticstep[y_axis]
#define xtic ticstep[x_axis]
register struct termentry *t = term;
register int curve;
int axis_zero[AXIS_ARRAY_SIZE]; /* axes in terminal coords for FIRST_X_AXIS, etc */
register struct curve_points *this_plot = NULL;
register int xl = 0, yl = 0; /* avoid gcc -Wall warning */
register int key_count = 0;
/* only a Pyramid would have this many registers! */
struct text_label *this_label;
struct arrow_def *this_arrow;
TBOOLEAN scaling;
char *s, *e;
/* so that macros for x_min etc pick up correct values
* until this is done properly
*/
x_axis = FIRST_X_AXIS;
y_axis = FIRST_Y_AXIS;
/* Apply the desired viewport offsets. */
if (y_min < y_max) {
y_min -= boff;
y_max += toff;
} else {
y_max -= boff;
y_min += toff;
}
if (x_min < x_max) {
x_min -= loff;
x_max += roff;
} else {
x_max -= loff;
x_min += roff;
}
/*
* In the beginning, this "empty range" test was for exact
* equality, eg y_min == y_max , but that caused an infinite
* loop once. Then the test was changed to check for being
* within the 'zero' threshold, fabs(y_max - y_min) < zero) ,
* but that prevented plotting data with ranges below 'zero'.
* Now it's an absolute equality test again, since fixup_range()
* should have widened empty ranges before we get here.
*/
if (x_min == x_max)
int_error("x_min should not equal x_max!", NO_CARET);
if (y_min == y_max)
int_error("y_min should not equal y_max!", NO_CARET);
term_init(); /* may set xmax/ymax */
/* compute boundary for plot (xleft, xright, ytop, ybot)
* also calculates tics, since xtics depend on xleft
* but xleft depends on ytics. Boundary calculations
* depend on term->v_char etc, so terminal must be
* initialised.
*/
scaling = (*t->scale) (xsize, ysize);
boundary(scaling, plots, pcount);
screen_ok = FALSE;
term_start_plot();
/* DRAW TICS AND GRID */
term_apply_lp_properties(&border_lp); /* border linetype */
largest_polar_circle = 0;
/* select first mapping */
x_axis = FIRST_X_AXIS;
y_axis = FIRST_Y_AXIS;
/* label first y axis tics */
if (ytics) {
int axis = map_x(ZERO);
/* set the globals ytick2d_callback() needs */
if (rotate_ytics && (*t->text_angle) (1)) {
tic_hjust = CENTRE;
tic_vjust = JUST_BOT;
rotate_tics = 1; /* HBB 980629 */
ytic_x += t->v_char / 2;
} else {
tic_hjust = RIGHT;
tic_vjust = JUST_CENTRE;
rotate_tics = 0; /* HBB 980629 */
}
if (ytics & TICS_MIRROR)
tic_mirror = xright;
else
tic_mirror = -1; /* no thank you */
if ((ytics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
tic_start = axis;
tic_direction = -1;
if (ytics & TICS_MIRROR)
tic_mirror = tic_start;
/* put text at boundary if axis is close to boundary */
tic_text = (((tic_start - xleft) > (3 * t->h_char)) ? tic_start : xleft) - t->h_char;
} else {
tic_start = xleft;
tic_direction = tic_in ? 1 : -1;
tic_text = ytic_x;
}
/* go for it */
gen_tics(FIRST_Y_AXIS, &yticdef,
work_grid.l_type & (GRID_Y | GRID_MY),
mytics, mytfreq, ytick2d_callback);
(*t->text_angle) (0); /* reset rotation angle */
}
/* label first x axis tics */
if (xtics) {
int axis = map_y(ZERO);
/* set the globals xtick2d_callback() needs */
if (rotate_xtics && (*t->text_angle) (1)) {
tic_hjust = RIGHT;
tic_vjust = JUST_CENTRE;
rotate_tics = 1; /* HBB 980629 */
} else {
tic_hjust = CENTRE;
tic_vjust = JUST_TOP;
rotate_tics = 0; /* HBB 980629 */
}
if (xtics & TICS_MIRROR)
tic_mirror = ytop;
else
tic_mirror = -1; /* no thank you */
if ((xtics & TICS_ON_AXIS) && !log_array[FIRST_Y_AXIS] && inrange(axis, ybot, ytop)) {
tic_start = axis;
tic_direction = -1;
if (xtics & TICS_MIRROR)
tic_mirror = tic_start;
/* put text at boundary if axis is close to boundary */
if (tic_start - ybot > 2 * t->v_char)
tic_text = tic_start - ticscale * t->v_tic - t->v_char;
else
tic_text = ybot - t->v_char;
} else {
tic_start = ybot;
tic_direction = tic_in ? 1 : -1;
tic_text = xtic_y;
}
/* go for it */
gen_tics(FIRST_X_AXIS, &xticdef,
work_grid.l_type & (GRID_X | GRID_MX),
mxtics, mxtfreq, xtick2d_callback);
(*t->text_angle) (0); /* reset rotation angle */
}
/* select second mapping */
x_axis = SECOND_X_AXIS;
y_axis = SECOND_Y_AXIS;
/* label second y axis tics */
if (y2tics) {
/* set the globalss ytick2d_callback() needs */
int axis = map_x(ZERO);
if (rotate_y2tics && (*t->text_angle) (1)) {
tic_hjust = CENTRE;
tic_vjust = JUST_TOP;
rotate_tics = 1; /* HBB 980629 */
} else {
tic_hjust = LEFT;
tic_vjust = JUST_CENTRE;
rotate_tics = 0; /* HBB 980629 */
}
if (y2tics & TICS_MIRROR)
tic_mirror = xleft;
else
tic_mirror = -1; /* no thank you */
if ((y2tics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
tic_start = axis;
tic_direction = 1;
if (y2tics & TICS_MIRROR)
tic_mirror = tic_start;
/* put text at boundary if axis is close to boundary */
tic_text = (((xright - tic_start) > (3 * t->h_char)) ? tic_start : xright) + t->h_char;
} else {
tic_start = xright;
tic_direction = tic_in ? -1 : 1;
tic_text = y2tic_x;
}
/* go for it */
gen_tics(SECOND_Y_AXIS, &y2ticdef,
work_grid.l_type & (GRID_Y2 | GRID_MY2),
my2tics, my2tfreq, ytick2d_callback);
(*t->text_angle) (0); /* reset rotation angle */
}
/* label second x axis tics */
if (x2tics) {
int axis = map_y(ZERO);
/* set the globals xtick2d_callback() needs */
if (rotate_x2tics && (*t->text_angle) (1)) {
tic_hjust = LEFT;
tic_vjust = JUST_CENTRE;
rotate_tics = 1; /* HBB 980629 */
} else {
tic_hjust = CENTRE;
tic_vjust = JUST_BOT;
rotate_tics = 0; /* HBB 980629 */
}
if (x2tics & TICS_MIRROR)
tic_mirror = ybot;
else
tic_mirror = -1; /* no thank you */
if ((x2tics & TICS_ON_AXIS) && !log_array[SECOND_Y_AXIS] && inrange(axis, ybot, ytop)) {
tic_start = axis;
tic_direction = 1;
if (x2tics & TICS_MIRROR)
tic_mirror = tic_start;
/* put text at boundary if axis is close to boundary */
tic_text = (((ytop - tic_start) > (2 * t->v_char)) ? tic_start : ytop) + t->v_char;
} else {
tic_start = ytop;
tic_direction = tic_in ? -1 : 1;
tic_text = x2tic_y;
}
/* go for it */
gen_tics(SECOND_X_AXIS, &x2ticdef,
work_grid.l_type & (GRID_X2 | GRID_MX2),
mx2tics, mx2tfreq, xtick2d_callback);
(*t->text_angle) (0); /* reset rotation angle */
}
/* select first mapping */
x_axis = FIRST_X_AXIS;
y_axis = FIRST_Y_AXIS;
/* RADIAL LINES FOR POLAR GRID */
/* note that draw_clip_line takes unsigneds, but (fortunately)
* clip_line takes signeds
*/
if (polar_grid_angle) {
double theta = 0;
int ox = map_x(0);
int oy = map_y(0);
term_apply_lp_properties(&grid_lp);
for (theta = 0; theta < 6.29; theta += polar_grid_angle) {
/* copy ox in case it gets moved (but it shouldn't) */
int oox = ox;
int ooy = oy;
int x = map_x(largest_polar_circle * cos(theta));
int y = map_y(largest_polar_circle * sin(theta));
if (clip_line(&oox, &ooy, &x, &y)) {
(*t->move) ((unsigned int) oox, (unsigned int) ooy);
(*t->vector) ((unsigned int) x, (unsigned int) y);
}
}
draw_clip_line(ox, oy,
map_x(largest_polar_circle * cos(theta)),
map_y(largest_polar_circle * sin(theta)));
}
/* DRAW AXES */
/* after grid so that axes linetypes are on top */
x_axis = FIRST_X_AXIS;
y_axis = FIRST_Y_AXIS; /* chose scaling */
axis_zero[FIRST_Y_AXIS] = map_y(0.0);
axis_zero[FIRST_X_AXIS] = map_x(0.0);
if (axis_zero[FIRST_Y_AXIS] < ybot || is_log_y)
axis_zero[FIRST_Y_AXIS] = ybot; /* save for impulse plotting */
else if (axis_zero[FIRST_Y_AXIS] >= ytop)
axis_zero[FIRST_Y_AXIS] = ytop;
else if (xzeroaxis.l_type > -3) {
term_apply_lp_properties(&xzeroaxis);
(*t->move) (xleft, axis_zero[FIRST_Y_AXIS]);
(*t->vector) (xright, axis_zero[FIRST_Y_AXIS]);
}
if ((yzeroaxis.l_type > -3) && !is_log_x
&& axis_zero[FIRST_X_AXIS] >= xleft
&& axis_zero[FIRST_X_AXIS] < xright) {
term_apply_lp_properties(&yzeroaxis);
(*t->move) (axis_zero[FIRST_X_AXIS], ybot);
(*t->vector) (axis_zero[FIRST_X_AXIS], ytop);
}
x_axis = SECOND_X_AXIS;
y_axis = SECOND_Y_AXIS; /* chose scaling */
axis_zero[SECOND_Y_AXIS] = map_y(0.0);
axis_zero[SECOND_X_AXIS] = map_x(0.0);
if (axis_zero[SECOND_Y_AXIS] < ybot || is_log_y2)
axis_zero[SECOND_Y_AXIS] = ybot; /* save for impulse plotting */
else if (axis_zero[SECOND_Y_AXIS] >= ytop)
axis_zero[SECOND_Y_AXIS] = ytop;
else if (x2zeroaxis.l_type > -3) {
term_apply_lp_properties(&x2zeroaxis);
(*t->move) (xleft, axis_zero[SECOND_Y_AXIS]);
(*t->vector) (xright, axis_zero[SECOND_Y_AXIS]);
}
if ((y2zeroaxis.l_type > -3) && !is_log_x2 &&
axis_zero[SECOND_X_AXIS] >= xleft &&
axis_zero[SECOND_X_AXIS] < xright) {
term_apply_lp_properties(&y2zeroaxis);
(*t->move) (axis_zero[SECOND_X_AXIS], ybot);
(*t->vector) (axis_zero[SECOND_X_AXIS], ytop);
}
/* DRAW PLOT BORDER */
if (draw_border) {
/* HBB 980609: just in case: move over to border linestyle only
* if border is to be drawn */
term_apply_lp_properties(&border_lp); /* border linetype */
(*t->move) (xleft, ybot);
if (border_south) {
(*t->vector) (xright, ybot);
} else {
(*t->move) (xright, ybot);
}
if (border_east) {
(*t->vector) (xright, ytop);
} else {
(*t->move) (xright, ytop);
}
if (border_north) {
(*t->vector) (xleft, ytop);
} else {
(*t->move) (xleft, ytop);
}
if (border_west) {
(*t->vector) (xleft, ybot);
} else {
(*t->move) (xleft, ybot);
}
}
/* YLABEL */
if (*ylabel.text) {
/* we worked out x-posn in boundary() */
if ((*t->text_angle) (1)) {
unsigned int x = ylabel_x + (t->v_char / 2);
unsigned int y = (ytop + ybot) / 2 + ylabel.yoffset * (t->h_char);
write_multiline(x, y, ylabel.text, CENTRE, JUST_TOP, 1, ylabel.font);
(*t->text_angle) (0);
} else {
/* really bottom just, but we know number of lines
so we need to adjust x-posn by one line */
unsigned int x = ylabel_x;
unsigned int y = ylabel_y;
write_multiline(x, y, ylabel.text, LEFT, JUST_TOP, 0, ylabel.font);
}
}
/* Y2LABEL */
if (*y2label.text) {
/* we worked out coordinates in boundary() */
if ((*t->text_angle) (1)) {
unsigned int x = y2label_x + (t->v_char / 2) - 1;
unsigned int y = (ytop + ybot) / 2 + y2label.yoffset * (t->h_char);
write_multiline(x, y, y2label.text, CENTRE, JUST_TOP, 1, y2label.font);
(*t->text_angle) (0);
} else {
/* really bottom just, but we know number of lines */
unsigned int x = y2label_x;
unsigned int y = y2label_y;
write_multiline(x, y, y2label.text, RIGHT, JUST_TOP, 0, y2label.font);
}
}
/* XLABEL */
if (*xlabel.text) {
unsigned int x = (xright + xleft) / 2 + xlabel.xoffset * (t->h_char);
unsigned int y = xlabel_y - t->v_char / 2; /* HBB */
write_multiline(x, y, xlabel.text, CENTRE, JUST_TOP, 0, xlabel.font);
}
/* PLACE TITLE */
if (*title.text) {
/* we worked out y-coordinate in boundary() */
unsigned int x = (xleft + xright) / 2 + title.xoffset * t->h_char;
unsigned int y = title_y - t->v_char / 2;
write_multiline(x, y, title.text, CENTRE, JUST_TOP, 0, title.font);
}
/* X2LABEL */
if (*x2label.text) {
/* we worked out y-coordinate in boundary() */
unsigned int x = (xright + xleft) / 2 + x2label.xoffset * (t->h_char);
unsigned int y = x2label_y - t->v_char / 2 - 1;
write_multiline(x, y, x2label.text, CENTRE, JUST_TOP, 0, x2label.font);
}
/* PLACE TIMEDATE */
if (*timelabel.text) {
/* we worked out coordinates in boundary() */
char *str;
time_t now;
unsigned int x = time_x;
unsigned int y = time_y;
time(&now);
/* there is probably now way to find out in advance how many
* chars strftime() writes */
str = gp_alloc(MAX_LINE_LEN + 1, "timelabel.text");
strftime(str, MAX_LINE_LEN, timelabel.text, localtime(&now));
if (timelabel_rotate && (*t->text_angle) (1)) {
x += t->v_char / 2; /* HBB */
if (timelabel_bottom)
write_multiline(x, y, str, LEFT, JUST_TOP, 1, timelabel.font);
else
write_multiline(x, y, str, RIGHT, JUST_TOP, 1, timelabel.font);
(*t->text_angle) (0);
} else {
y -= t->v_char / 2; /* HBB */
if (timelabel_bottom)
write_multiline(x, y, str, LEFT, JUST_BOT, 0, timelabel.font);
else
write_multiline(x, y, str, LEFT, JUST_TOP, 0, timelabel.font);
}
}
/* PLACE LABELS */
for (this_label = first_label; this_label != NULL;
this_label = this_label->next) {
unsigned int x, y;
map_position(&this_label->place, &x, &y, "label");
if (this_label->rotate && (*t->text_angle) (1)) {
write_multiline(x, y, this_label->text, this_label->pos, JUST_TOP, 1, this_label->font);
(*t->text_angle) (0);
} else {
write_multiline(x, y, this_label->text, this_label->pos, JUST_TOP, 0, this_label->font);
}
}
/* PLACE ARROWS */
for (this_arrow = first_arrow; this_arrow != NULL;
this_arrow = this_arrow->next) {
unsigned int sx, sy, ex, ey;
map_position(&this_arrow->start, &sx, &sy, "arrow");
map_position(&this_arrow->end, &ex, &ey, "arrow");
term_apply_lp_properties(&(this_arrow->lp_properties));
(*t->arrow) (sx, sy, ex, ey, this_arrow->head);
}
/* WORK OUT KEY SETTINGS AND DO KEY TITLE / BOX */
if (lkey) { /* may have been cancelled if something went wrong */
/* just use key_xl etc worked out in boundary() */
xl = key_xl + key_size_left;
yl = key_yt;
if (*key_title) {
char *ss = gp_alloc(strlen(key_title) + 2, "tmp string ss");
strcpy(ss, key_title);
strcat(ss, "\n");
s = ss;
yl -= t->v_char / 2;
while ((e = (char *) strchr(s, '\n')) != NULL) {
*e = '\0';
if (key_just == JLEFT) {
(*t->justify_text) (LEFT);
(*t->put_text) (xl + key_text_left, yl, s);
} else {
if ((*t->justify_text) (RIGHT)) {
(*t->put_text) (xl + key_text_right, yl, s);
} else {
int x = xl + key_text_right - (t->h_char) * strlen(s);
if (key_hpos == TOUT || inrange(x, xleft, xright))
(*t->put_text) (x, yl, s);
}
}
s = ++e;
yl -= t->v_char;
}
yl += t->v_char / 2;
free(ss);
}
yl_ref = yl -= key_entry_height / 2; /* centralise the keys */
key_count = 0;
if (key_box.l_type > -3) {
term_apply_lp_properties(&key_box);
(*t->move) (key_xl, key_yb);
(*t->vector) (key_xl, key_yt);
(*t->vector) (key_xr, key_yt);
(*t->vector) (key_xr, key_yb);
(*t->vector) (key_xl, key_yb);
/* draw a horizontal line between key title
and first entry *//* JFi */
(*t->move) (key_xl, key_yt - (ktitl_lines) * t->v_char); /* JFi */
(*t->vector) (key_xr, key_yt - (ktitl_lines) * t->v_char); /* JFi */
}
} /* lkey */
/* DRAW CURVES */
this_plot = plots;
for (curve = 0; curve < pcount; this_plot = this_plot->next_cp, curve++) {
int localkey = lkey; /* a local copy */
/* set scaling for this plot's axes */
x_axis = this_plot->x_axis;
y_axis = this_plot->y_axis;
term_apply_lp_properties(&(this_plot->lp_properties));
if (this_plot->title && !*this_plot->title) {
localkey = 0;
} else {
if (localkey != 0 && this_plot->title) {
key_count++;
if (key_just == JLEFT) {
(*t->justify_text) (LEFT);
(*t->put_text) (xl + key_text_left,
yl, this_plot->title);
} else {
if ((*t->justify_text) (RIGHT)) {
(*t->put_text) (xl + key_text_right,
yl, this_plot->title);
} else {
int x = xl + key_text_right - (t->h_char) * strlen(this_plot->title);
if (key_hpos == TOUT ||
i_inrange(x, xleft, xright))
(*t->put_text) (x, yl, this_plot->title);
}
}
/* draw sample depending on bits set in plot_style */
if ((this_plot->plot_style & 1) ||
((this_plot->plot_style & 4) && this_plot->plot_type == DATA)) { /* errors for data plots only */
(*t->move) (xl + key_sample_left, yl);
(*t->vector) (xl + key_sample_right, yl);
}
/* oops - doing the point sample now breaks postscript
* terminal for example, which changes current line style
* when drawing a point, but does not restore it.
* We simply draw the point sample after plotting
*/
if (this_plot->plot_type == DATA &&
(this_plot->plot_style & 4) &&
bar_size > 0.0) {
(*t->move) (xl + key_sample_left, yl + ERRORBARTIC);
(*t->vector) (xl + key_sample_left, yl - ERRORBARTIC);
(*t->move) (xl + key_sample_right, yl + ERRORBARTIC);
(*t->vector) (xl + key_sample_right, yl - ERRORBARTIC);
}
}
}
/* and now the curves, plus any special key requirements */
/* be sure to draw all lines before drawing any points */
switch (this_plot->plot_style) {
/*{{{ IMPULSE */
case IMPULSES:
plot_impulses(this_plot, axis_zero[x_axis], axis_zero[y_axis]);
break;
/*}}} */
/*{{{ LINES */
case LINES:
plot_lines(this_plot);
break;
/*}}} */
/*{{{ STEPS */
case STEPS:
plot_steps(this_plot);
break;
/*}}} */
/*{{{ FSTEPS */
case FSTEPS:
plot_fsteps(this_plot);
break;
/*}}} */
/*{{{ HISTEPS */
case HISTEPS:
plot_histeps(this_plot);
break;
/*}}} */
/*{{{ POINTSTYLE */
case POINTSTYLE:
plot_points(this_plot);
break;
/*}}} */
/*{{{ LINESPOINTS */
case LINESPOINTS:
plot_lines(this_plot);
plot_points(this_plot);
break;
/*}}} */
/*{{{ DOTS */
case DOTS:
if (localkey != 0 && this_plot->title) {
(*t->point) (xl + key_point_offset, yl, -1);
}
plot_dots(this_plot);
break;
/*}}} */
/*{{{ YERRORBARS */
case YERRORBARS:{
plot_bars(this_plot);
plot_points(this_plot);
break;
}
/*}}} */
/*{{{ XERRORBARS */
case XERRORBARS:{
plot_bars(this_plot);
plot_points(this_plot);
}
/*}}} */
/*{{{ XYERRORBARS */
case XYERRORBARS:
plot_bars(this_plot);
plot_points(this_plot);
break;
/*}}} */
/*{{{ BOXXYERROR */
case BOXXYERROR:
plot_boxes(this_plot, axis_zero[y_axis]);
break;
/*}}} */
/*{{{ BOXERROR (falls through to) */
case BOXERROR:
plot_bars(this_plot);
/* no break */
/*}}} */
/*{{{ BOXES */
case BOXES:
plot_boxes(this_plot, axis_zero[y_axis]);
break;
/*}}} */
/*{{{ VECTOR */
case VECTOR:
plot_vectors(this_plot);
break;
/*}}} */
/*{{{ FINANCEBARS */
case FINANCEBARS:
plot_f_bars(this_plot);
break;
/*}}} */
/*{{{ CANDLESTICKS */
case CANDLESTICKS:
plot_c_bars(this_plot);
break;
/*}}} */
}
if (localkey && this_plot->title) {
/* we deferred point sample until now */
if (this_plot->plot_style & 2)
(*t->point) (xl + key_point_offset, yl,
this_plot->lp_properties.p_type);
if (key_count >= key_rows) {
yl = yl_ref;
xl += key_col_wth;
key_count = 0;
} else
yl = yl - key_entry_height;
}
}
term_end_plot();
}
/* BODGES */
#undef ytic
#undef xtic
/* plot_impulses:
* Plot the curves in IMPULSES style
*/
static void plot_impulses(plot, yaxis_x, xaxis_y)
struct curve_points *plot;
int yaxis_x, xaxis_y;
{
int i;
int x, y;
struct termentry *t = term;
for (i = 0; i < plot->p_count; i++) {
switch (plot->points[i].type) {
case INRANGE:{
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
break;
}
case OUTRANGE:{
if (!inrange(plot->points[i].x, x_min, x_max))
continue;
x = map_x(plot->points[i].x);
if ((y_min < y_max
&& plot->points[i].y < y_min)
|| (y_max < y_min
&& plot->points[i].y > y_min))
y = map_y(y_min);
else
y = map_y(y_max);
break;
}
default: /* just a safety */
case UNDEFINED:{
continue;
}
}
if (polar)
(*t->move) (yaxis_x, xaxis_y);
else
(*t->move) (x, xaxis_y);
(*t->vector) (x, y);
}
}
/* plot_lines:
* Plot the curves in LINES style
*/
static void plot_lines(plot)
struct curve_points *plot;
{
int i; /* point index */
int x, y; /* point in terminal coordinates */
struct termentry *t = term;
enum coord_type prev = UNDEFINED; /* type of previous point */
double ex, ey; /* an edge point */
double lx[2], ly[2]; /* two edge points */
for (i = 0; i < plot->p_count; i++) {
switch (plot->points[i].type) {
case INRANGE:{
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
if (prev == INRANGE) {
(*t->vector) (x, y);
} else if (prev == OUTRANGE) {
/* from outrange to inrange */
if (!clip_lines1) {
(*t->move) (x, y);
} else {
edge_intersect(plot->points, i, &ex, &ey);
(*t->move) (map_x(ex), map_y(ey));
(*t->vector) (x, y);
}
} else { /* prev == UNDEFINED */
(*t->move) (x, y);
(*t->vector) (x, y);
}
break;
}
case OUTRANGE:{
if (prev == INRANGE) {
/* from inrange to outrange */
if (clip_lines1) {
edge_intersect(plot->points, i, &ex, &ey);
(*t->vector) (map_x(ex), map_y(ey));
}
} else if (prev == OUTRANGE) {
/* from outrange to outrange */
if (clip_lines2) {
if (two_edge_intersect(plot->points, i, lx, ly)) {
(*t->move) (map_x(lx[0]), map_y(ly[0]));
(*t->vector) (map_x(lx[1]), map_y(ly[1]));
}
}
}
break;
}
default: /* just a safety */
case UNDEFINED:{
break;
}
}
prev = plot->points[i].type;
}
}
/* XXX - JG */
/* plot_steps:
* Plot the curves in STEPS style
*/
static void plot_steps(plot)
struct curve_points *plot;
{
int i; /* point index */
int x, y; /* point in terminal coordinates */
struct termentry *t = term;
enum coord_type prev = UNDEFINED; /* type of previous point */
double ex, ey; /* an edge point */
double lx[2], ly[2]; /* two edge points */
int yprev = 0; /* previous point coordinates */
for (i = 0; i < plot->p_count; i++) {
switch (plot->points[i].type) {
case INRANGE:{
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
if (prev == INRANGE) {
(*t->vector) (x, yprev);
(*t->vector) (x, y);
} else if (prev == OUTRANGE) {
/* from outrange to inrange */
if (!clip_lines1) {
(*t->move) (x, y);
} else { /* find edge intersection */
edge_intersect_steps(plot->points, i, &ex, &ey);
(*t->move) (map_x(ex), map_y(ey));
(*t->vector) (x, map_y(ey));
(*t->vector) (x, y);
}
} else { /* prev == UNDEFINED */
(*t->move) (x, y);
(*t->vector) (x, y);
}
yprev = y;
break;
}
case OUTRANGE:{
if (prev == INRANGE) {
/* from inrange to outrange */
if (clip_lines1) {
edge_intersect_steps(plot->points, i, &ex, &ey);
(*t->vector) (map_x(ex), yprev);
(*t->vector) (map_x(ex), map_y(ey));
}
} else if (prev == OUTRANGE) {
/* from outrange to outrange */
if (clip_lines2) {
if (two_edge_intersect_steps(plot->points, i, lx, ly)) {
(*t->move) (map_x(lx[0]), map_y(ly[0]));
(*t->vector) (map_x(lx[1]), map_y(ly[0]));
(*t->vector) (map_x(lx[1]), map_y(ly[1]));
}
}
}
break;
}
default: /* just a safety */
case UNDEFINED:{
break;
}
}
prev = plot->points[i].type;
}
}
/* XXX - HOE */
/* plot_fsteps:
* Plot the curves in STEPS style by step on forward yvalue
*/
static void plot_fsteps(plot)
struct curve_points *plot;
{
int i; /* point index */
int x, y; /* point in terminal coordinates */
struct termentry *t = term;
enum coord_type prev = UNDEFINED; /* type of previous point */
double ex, ey; /* an edge point */
double lx[2], ly[2]; /* two edge points */
int xprev = 0; /* previous point coordinates */
for (i = 0; i < plot->p_count; i++) {
switch (plot->points[i].type) {
case INRANGE:{
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
if (prev == INRANGE) {
(*t->vector) (xprev, y);
(*t->vector) (x, y);
} else if (prev == OUTRANGE) {
/* from outrange to inrange */
if (!clip_lines1) {
(*t->move) (x, y);
} else { /* find edge intersection */
edge_intersect_fsteps(plot->points, i, &ex, &ey);
(*t->move) (map_x(ex), map_y(ey));
(*t->vector) (map_x(ex), y);
(*t->vector) (x, y);
}
} else { /* prev == UNDEFINED */
(*t->move) (x, y);
(*t->vector) (x, y);
}
xprev = x;
break;
}
case OUTRANGE:{
if (prev == INRANGE) {
/* from inrange to outrange */
if (clip_lines1) {
edge_intersect_fsteps(plot->points, i, &ex, &ey);
(*t->vector) (xprev, map_y(ey));
(*t->vector) (map_x(ex), map_y(ey));
}
} else if (prev == OUTRANGE) {
/* from outrange to outrange */
if (clip_lines2) {
if (two_edge_intersect_fsteps(plot->points, i, lx, ly)) {
(*t->move) (map_x(lx[0]), map_y(ly[0]));
(*t->vector) (map_x(lx[0]), map_y(ly[1]));
(*t->vector) (map_x(lx[1]), map_y(ly[1]));
}
}
}
break;
}
default: /* just a safety */
case UNDEFINED:{
break;
}
}
prev = plot->points[i].type;
}
}
/* CAC */
/* plot_histeps:
* Plot the curves in HISTEPS style
*/
static void plot_histeps(plot)
struct curve_points *plot;
{
int i; /* point index */
int hold, bigi; /* indices for sorting */
int xl, yl; /* cursor position in terminal coordinates */
struct termentry *t = term;
double x, y, xn, yn; /* point position */
int *gl, goodcount; /* array to hold list of valid points */
/* preliminary count of points inside array */
goodcount = 0;
for (i = 0; i < plot->p_count; i++)
if (plot->points[i].type == INRANGE ||
plot->points[i].type == OUTRANGE)
++goodcount;
if (goodcount < 2)
return; /* cannot plot less than 2 points */
gl = (int *) gp_alloc(goodcount * sizeof(int), "histeps valid point mapping");
if (gl == NULL)
return;
/* fill gl array with indexes of valid (non-undefined) points. */
goodcount = 0;
for (i = 0; i < plot->p_count; i++)
if (plot->points[i].type == INRANGE ||
plot->points[i].type == OUTRANGE) {
gl[goodcount] = i;
++goodcount;
}
/* sort the data */
for (bigi = i = 1; i < goodcount;) {
if (plot->points[gl[i]].x < plot->points[gl[i - 1]].x) {
hold = gl[i];
gl[i] = gl[i - 1];
gl[i - 1] = hold;
if (i > 1) {
i--;
continue;
}
}
i = ++bigi;
}
x = (3.0 * plot->points[gl[0]].x - plot->points[gl[1]].x) / 2.0;
y = 0.0;
xl = map_x(x);
yl = map_y(y);
(*t->move) (xl, yl);
for (i = 0; i < goodcount - 1; i++) { /* loop over all points except last */
yn = plot->points[gl[i]].y;
xn = (plot->points[gl[i]].x + plot->points[gl[i + 1]].x) / 2.0;
histeps_vertical(&xl, &yl, x, y, yn);
histeps_horizontal(&xl, &yl, x, xn, yn);
x = xn;
y = yn;
}
yn = plot->points[gl[i]].y;
xn = (3.0 * plot->points[gl[i]].x - plot->points[gl[i - 1]].x) / 2.0;
histeps_vertical(&xl, &yl, x, y, yn);
histeps_horizontal(&xl, &yl, x, xn, yn);
histeps_vertical(&xl, &yl, xn, yn, 0.0);
free(gl);
}
/* CAC
* Draw vertical line for the histeps routine.
* Performs clipping.
*/
static void histeps_vertical(xl, yl, x, y1, y2)
int *xl, *yl; /* keeps track of "cursor" position */
double x, y1, y2; /* coordinates of vertical line */
{
struct termentry *t = term;
/* global x_min, x_max, y_min, y_max */
int xm, y1m, y2m;
if ((y1 < y_min && y2 < y_min) ||
(y1 > y_max && y2 > y_max) ||
x < x_min ||
x > x_max)
return;
if (y1 < y_min)
y1 = y_min;
if (y1 > y_max)
y1 = y_max;
if (y2 < y_min)
y2 = y_min;
if (y2 > y_max)
y2 = y_max;
xm = map_x(x);
y1m = map_y(y1);
y2m = map_y(y2);
if (y1m != *yl || xm != *xl)
(*t->move) (xm, y1m);
(*t->vector) (xm, y2m);
*xl = xm;
*yl = y2m;
return;
}
/* CAC
* Draw horizontal line for the histeps routine.
* Performs clipping.
*/
static void histeps_horizontal(xl, yl, x1, x2, y)
int *xl, *yl; /* keeps track of "cursor" position */
double x1, x2, y; /* coordinates of vertical line */
{
struct termentry *t = term;
/* global x_min, x_max, y_min, y_max */
int x1m, x2m, ym;
if ((x1 < x_min && x2 < x_min) ||
(x1 > x_max && x2 > x_max) ||
y < y_min ||
y > y_max)
return;
if (x1 < x_min)
x1 = x_min;
if (x1 > x_max)
x1 = x_max;
if (x2 < x_min)
x2 = x_min;
if (x2 > x_max)
x2 = x_max;
ym = map_y(y);
x1m = map_x(x1);
x2m = map_x(x2);
if (x1m != *xl || ym != *yl)
(*t->move) (x1m, ym);
(*t->vector) (x2m, ym);
*xl = x2m;
*yl = ym;
return;
}
/* plot_bars:
* Plot the curves in ERRORBARS style
* we just plot the bars; the points are plotted in plot_points
*/
static void plot_bars(plot)
struct curve_points *plot;
{
int i; /* point index */
struct termentry *t = term;
double x, y; /* position of the bar */
double ylow, yhigh; /* the ends of the bars */
double xlow, xhigh;
double x1, y1, x2, y2, slope; /* parameters for polar error bars */
unsigned int xM, ylowM, yhighM; /* the mapped version of above */
unsigned int yM, xlowM, xhighM;
TBOOLEAN low_inrange, high_inrange;
int tic = ERRORBARTIC;
/* Limitation: no boxes with x errorbars */
if ((plot->plot_style == YERRORBARS) || (plot->plot_style == XYERRORBARS) ||
(plot->plot_style == BOXERROR)) {
/* Draw the vertical part of the bar */
for (i = 0; i < plot->p_count; i++) {
/* undefined points don't count */
if (plot->points[i].type == UNDEFINED)
continue;
/* check to see if in xrange */
x = plot->points[i].x;
if (!inrange(x, x_min, x_max))
continue;
xM = map_x(x);
/* check to see if in yrange */
y = plot->points[i].y;
if (!inrange(y, y_min, y_max))
continue;
yM = map_y(y);
/* find low and high points of bar, and check yrange */
yhigh = plot->points[i].yhigh;
ylow = plot->points[i].ylow;
high_inrange = inrange(yhigh, y_min, y_max);
low_inrange = inrange(ylow, y_min, y_max);
/* compute the plot position of yhigh */
if (high_inrange)
yhighM = map_y(yhigh);
else if (samesign(yhigh - y_max, y_max - y_min))
yhighM = map_y(y_max);
else
yhighM = map_y(y_min);
/* compute the plot position of ylow */
if (low_inrange)
ylowM = map_y(ylow);
else if (samesign(ylow - y_max, y_max - y_min))
ylowM = map_y(y_max);
else
ylowM = map_y(y_min);
if (!high_inrange && !low_inrange && ylowM == yhighM)
/* both out of range on the same side */
continue;
/* find low and high points of bar, and check xrange */
xhigh = plot->points[i].xhigh;
xlow = plot->points[i].xlow;
high_inrange = inrange(xhigh, x_min, x_max);
low_inrange = inrange(xlow, x_min, x_max);
/* compute the plot position of xhigh */
if (high_inrange)
xhighM = map_x(xhigh);
else if (samesign(xhigh - x_max, x_max - x_min))
xhighM = map_x(x_max);
else
xhighM = map_x(x_min);
/* compute the plot position of xlow */
if (low_inrange)
xlowM = map_x(xlow);
else if (samesign(xlow - x_max, x_max - x_min))
xlowM = map_x(x_max);
else
xlowM = map_x(x_min);
if (!high_inrange && !low_inrange && xlowM == xhighM)
/* both out of range on the same side */
continue;
/* by here everything has been mapped */
if (!polar) {
/* HBB 981130: use Igor's routine *only* for polar errorbars */
(*t->move) (xM, ylowM);
/* draw the main bar */
(*t->vector) (xM, yhighM);
if (bar_size > 0.0) {
/* draw the bottom tic */
(*t->move) ((unsigned int) (xM - bar_size * tic), ylowM);
(*t->vector) ((unsigned int) (xM + bar_size * tic), ylowM);
/* draw the top tic */
(*t->move) ((unsigned int) (xM - bar_size * tic), yhighM);
(*t->vector) ((unsigned int) (xM + bar_size * tic), yhighM);
}
} else {
/* HBB 981130: see above */
/* The above has been replaced by Igor inorder to get errorbars
coming out in polar mode AND to stop the bar from going
through the symbol */
if ((xhighM - xlowM) * (xhighM - xlowM) + (yhighM - ylowM) * (yhighM - ylowM)
> pointsize * tic * pointsize * tic * 4.5) {
/* Only plot the error bar if it is bigger than the
* symbol */
/* The factor of 4.5 should strictly be 4.0, but it looks
* better to drop the error bar if it is only slightly
* bigger than the symbol, Igor. */
if (xlowM == xhighM) {
(*t->move) (xM, ylowM);
/* draw the main bar to the symbol end */
(*t->vector) (xM, (unsigned int) (yM - pointsize * tic));
(*t->move) (xM, (unsigned int) (yM + pointsize * tic));
/* draw the other part of the main bar */
(*t->vector) (xM, yhighM);
} else {
(*t->move) (xlowM, ylowM);
/* draw the main bar in polar mode. Note that here
* the bar is drawn through the symbol. I tried to
* fix this, but got into trouble with the two bars
* (on either side of symbol) not being perfectly
* parallel due to mapping considerations. Igor
*/
(*t->vector) (xhighM, yhighM);
}
if (bar_size > 0.0) {
/* The following attempts to ensure that the tics
* are perpendicular to the error bar, Igor. */
/*perpendicular to the main bar */
slope = (xlowM * 1.0 - xhighM * 1.0) / (yhighM * 1.0 - ylowM * 1.0 + 1e-10);
x1 = xlowM + bar_size * tic / sqrt(1.0 + slope * slope);
x2 = xlowM - bar_size * tic / sqrt(1.0 + slope * slope);
y1 = slope * (x1 - xlowM) + ylowM;
y2 = slope * (x2 - xlowM) + ylowM;
/* draw the bottom tic */
(*t->move) ((unsigned int) x1, (unsigned int) y1);
(*t->vector) ((unsigned int) x2, (unsigned int) y2);
x1 = xhighM + bar_size * tic / sqrt(1.0 + slope * slope);
x2 = xhighM - bar_size * tic / sqrt(1.0 + slope * slope);
y1 = slope * (x1 - xhighM) + yhighM;
y2 = slope * (x2 - xhighM) + yhighM;
/* draw the top tic */
(*t->move) ((unsigned int) x1, (unsigned int) y1);
(*t->vector) ((unsigned int) x2, (unsigned int) y2);
} /* if error bar is bigger than symbol */
}
} /* HBB 981130: see above */
} /* for loop */
} /* if yerrorbars OR xyerrorbars */
if ((plot->plot_style == XERRORBARS) || (plot->plot_style == XYERRORBARS)) {
/* Draw the horizontal part of the bar */
for (i = 0; i < plot->p_count; i++) {
/* undefined points don't count */
if (plot->points[i].type == UNDEFINED)
continue;
/* check to see if in yrange */
y = plot->points[i].y;
if (!inrange(y, y_min, y_max))
continue;
yM = map_y(y);
/* find low and high points of bar, and check xrange */
xhigh = plot->points[i].xhigh;
xlow = plot->points[i].xlow;
high_inrange = inrange(xhigh, x_min, x_max);
low_inrange = inrange(xlow, x_min, x_max);
/* compute the plot position of xhigh */
if (high_inrange)
xhighM = map_x(xhigh);
else if (samesign(xhigh - x_max, x_max - x_min))
xhighM = map_x(x_max);
else
xhighM = map_x(x_min);
/* compute the plot position of xlow */
if (low_inrange)
xlowM = map_x(xlow);
else if (samesign(xlow - x_max, x_max - x_min))
xlowM = map_x(x_max);
else
xlowM = map_x(x_min);
if (!high_inrange && !low_inrange && xlowM == xhighM)
/* both out of range on the same side */
continue;
/* by here everything has been mapped */
(*t->move) (xlowM, yM);
(*t->vector) (xhighM, yM); /* draw the main bar */
if (bar_size > 0.0) {
(*t->move) (xlowM, (unsigned int) (yM - bar_size * tic)); /* draw the left tic */
(*t->vector) (xlowM, (unsigned int) (yM + bar_size * tic));
(*t->move) (xhighM, (unsigned int) (yM - bar_size * tic)); /* draw the right tic */
(*t->vector) (xhighM, (unsigned int) (yM + bar_size * tic));
}
} /* for loop */
} /* if xerrorbars OR xyerrorbars */
}
/* plot_boxes:
* Plot the curves in BOXES style
*/
static void plot_boxes(plot, xaxis_y)
struct curve_points *plot;
int xaxis_y;
{
int i; /* point index */
int xl, xr, yt; /* point in terminal coordinates */
double dxl, dxr, dyt;
struct termentry *t = term;
enum coord_type prev = UNDEFINED; /* type of previous point */
TBOOLEAN boxxy = (plot->plot_style == BOXXYERROR);
for (i = 0; i < plot->p_count; i++) {
switch (plot->points[i].type) {
case OUTRANGE:
case INRANGE:{
if (plot->points[i].z < 0.0) {
/* need to auto-calc width */
/* ASSERT(boxwidth <= 0.0); - else graphics.c
* provides width */
/* calculate width */
if (prev != UNDEFINED)
dxl = (plot->points[i - 1].x - plot->points[i].x) / 2.0;
else
dxl = 0.0;
if (i < plot->p_count - 1) {
if (plot->points[i + 1].type != UNDEFINED)
dxr = (plot->points[i + 1].x - plot->points[i].x) / 2.0;
else
dxr = -dxl;
} else {
dxr = -dxl;
}
if (prev == UNDEFINED)
dxl = -dxr;
dxl = plot->points[i].x + dxl;
dxr = plot->points[i].x + dxr;
} else { /* z >= 0 */
dxr = plot->points[i].xhigh;
dxl = plot->points[i].xlow;
}
if (boxxy) {
dyt = plot->points[i].yhigh;
xaxis_y = map_y(plot->points[i].ylow);
} else {
dyt = plot->points[i].y;
}
/* clip to border */
if ((y_min < y_max && dyt < y_min)
|| (y_max < y_min && dyt > y_min))
dyt = y_min;
if ((y_min < y_max && dyt > y_max)
|| (y_max < y_min && dyt < y_max))
dyt = y_max;
if ((x_min < x_max && dxr < x_min)
|| (x_max < x_min && dxr > x_min))
dxr = x_min;
if ((x_min < x_max && dxr > x_max)
|| (x_max < x_min && dxr < x_max))
dxr = x_max;
if ((x_min < x_max && dxl < x_min)
|| (x_max < x_min && dxl > x_min))
dxl = x_min;
if ((x_min < x_max && dxl > x_max)
|| (x_max < x_min && dxl < x_max))
dxl = x_max;
xl = map_x(dxl);
xr = map_x(dxr);
yt = map_y(dyt);
(*t->move) (xl, xaxis_y);
(*t->vector) (xl, yt);
(*t->vector) (xr, yt);
(*t->vector) (xr, xaxis_y);
(*t->vector) (xl, xaxis_y);
break;
} /* case OUTRANGE, INRANGE */
default: /* just a safety */
case UNDEFINED:{
break;
}
} /* switch point-type */
prev = plot->points[i].type;
} /*loop */
}
/* plot_points:
* Plot the curves in POINTSTYLE style
*/
static void plot_points(plot)
struct curve_points *plot;
{
int i;
int x, y;
struct termentry *t = term;
for (i = 0; i < plot->p_count; i++) {
if (plot->points[i].type == INRANGE) {
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
/* do clipping if necessary */
if (!clip_points ||
(x >= xleft + p_width && y >= ybot + p_height
&& x <= xright - p_width && y <= ytop - p_height))
(*t->point) (x, y, plot->lp_properties.p_type);
}
}
}
/* plot_dots:
* Plot the curves in DOTS style
*/
static void plot_dots(plot)
struct curve_points *plot;
{
int i;
int x, y;
struct termentry *t = term;
for (i = 0; i < plot->p_count; i++) {
if (plot->points[i].type == INRANGE) {
x = map_x(plot->points[i].x);
y = map_y(plot->points[i].y);
/* point type -1 is a dot */
(*t->point) (x, y, -1);
}
}
}
/* plot_vectors:
* Plot the curves in VECTORS style
*/
static void plot_vectors(plot)
struct curve_points *plot;
{
int i;
int x1, y1, x2, y2;
struct termentry *t = term;
for (i = 0; i < plot->p_count; i++) {
if (plot->points[i].type == INRANGE) {
x1 = map_x(plot->points[i].xlow);
y1 = map_y(plot->points[i].ylow);
x2 = map_x(plot->points[i].xhigh);
y2 = map_y(plot->points[i].yhigh);
(*t->arrow) (x1, y1, x2, y2, TRUE);
}
}
}
/* plot_f_bars() - finance bars */
static void plot_f_bars(plot)
struct curve_points *plot;
{
int i; /* point index */
struct termentry *t = term;
double x; /* position of the bar */
double ylow, yhigh, yclose, yopen; /* the ends of the bars */
unsigned int xM, ylowM, yhighM; /* the mapped version of above */
TBOOLEAN low_inrange, high_inrange;
int tic = ERRORBARTIC / 2;
for (i = 0; i < plot->p_count; i++) {
/* undefined points don't count */
if (plot->points[i].type == UNDEFINED)
continue;
/* check to see if in xrange */
x = plot->points[i].x;
if (!inrange(x, x_min, x_max))
continue;
xM = map_x(x);
/* find low and high points of bar, and check yrange */
yhigh = plot->points[i].yhigh;
ylow = plot->points[i].ylow;
yclose = plot->points[i].z;
yopen = plot->points[i].y;
high_inrange = inrange(yhigh, y_min, y_max);
low_inrange = inrange(ylow, y_min, y_max);
/* compute the plot position of yhigh */
if (high_inrange)
yhighM = map_y(yhigh);
else if (samesign(yhigh - y_max, y_max - y_min))
yhighM = map_y(y_max);
else
yhighM = map_y(y_min);
/* compute the plot position of ylow */
if (low_inrange)
ylowM = map_y(ylow);
else if (samesign(ylow - y_max, y_max - y_min))
ylowM = map_y(y_max);
else
ylowM = map_y(y_min);
if (!high_inrange && !low_inrange && ylowM == yhighM)
/* both out of range on the same side */
continue;
/* by here everything has been mapped */
(*t->move) (xM, ylowM);
(*t->vector) (xM, yhighM); /* draw the main bar */
/* draw the open tic */
(*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
(*t->vector) (xM, map_y(yopen));
/* draw the close tic */
(*t->move) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
(*t->vector) (xM, map_y(yclose));
}
}
/* plot_c_bars:
* Plot the curves in CANDLESTICSK style
* we just plot the bars; the points are not plotted
*/
static void plot_c_bars(plot)
struct curve_points *plot;
{
int i; /* point index */
struct termentry *t = term;
double x; /* position of the bar */
double ylow, yhigh, yclose, yopen; /* the ends of the bars */
unsigned int xM, ylowM, yhighM; /* the mapped version of above */
TBOOLEAN low_inrange, high_inrange;
int tic = ERRORBARTIC / 2;
for (i = 0; i < plot->p_count; i++) {
/* undefined points don't count */
if (plot->points[i].type == UNDEFINED)
continue;
/* check to see if in xrange */
x = plot->points[i].x;
if (!inrange(x, x_min, x_max))
continue;
xM = map_x(x);
/* find low and high points of bar, and check yrange */
yhigh = plot->points[i].yhigh;
ylow = plot->points[i].ylow;
yclose = plot->points[i].z;
yopen = plot->points[i].y;
high_inrange = inrange(yhigh, y_min, y_max);
low_inrange = inrange(ylow, y_min, y_max);
/* compute the plot position of yhigh */
if (high_inrange)
yhighM = map_y(yhigh);
else if (samesign(yhigh - y_max, y_max - y_min))
yhighM = map_y(y_max);
else
yhighM = map_y(y_min);
/* compute the plot position of ylow */
if (low_inrange)
ylowM = map_y(ylow);
else if (samesign(ylow - y_max, y_max - y_min))
ylowM = map_y(y_max);
else
ylowM = map_y(y_min);
if (!high_inrange && !low_inrange && ylowM == yhighM)
/* both out of range on the same side */
continue;
/* by here everything has been mapped */
if (yopen <= yclose) {
(*t->move) (xM, ylowM);
(*t->vector) (xM, map_y(yopen)); /* draw the lower bar */
/* draw the open tic */
(*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
(*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
(*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
(*t->move) (xM, map_y(yclose)); /* draw the close tic */
(*t->vector) (xM, yhighM);
} else {
(*t->move) (xM, ylowM);
(*t->vector) (xM, yhighM);
/* draw the open tic */
(*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
(*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
(*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
/* draw the close tic */
(*t->move) ((unsigned int) (xM - bar_size * tic / 2), map_y(yclose));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM - bar_size * tic / 2), map_y(yopen));
/* draw the close tic */
(*t->move) ((unsigned int) (xM + bar_size * tic / 2), map_y(yclose));
/* draw the open tic */
(*t->vector) ((unsigned int) (xM + bar_size * tic / 2), map_y(yopen));
}
}
}
/* single edge intersection algorithm */
/* Given two points, one inside and one outside the plot, return
* the point where an edge of the plot intersects the line segment defined
* by the two points.
*/
static void edge_intersect(points, i, ex, ey)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *ex, *ey; /* the point where it crosses an edge */
{
/* global x_min, x_max, y_min, x_max */
double ix = points[i - 1].x;
double iy = points[i - 1].y;
double ox = points[i].x;
double oy = points[i].y;
double x, y; /* possible intersection point */
if (points[i].type == INRANGE) {
/* swap points around so that ix/ix/iz are INRANGE and
* ox/oy/oz are OUTRANGE
*/
x = ix;
ix = ox;
ox = x;
y = iy;
iy = oy;
oy = y;
}
/* nasty degenerate cases, effectively drawing to an infinity point (?)
* cope with them here, so don't process them as a "real" OUTRANGE point
*
* If more than one coord is -VERYLARGE, then can't ratio the "infinities"
* so drop out by returning the INRANGE point.
*
* Obviously, only need to test the OUTRANGE point (coordinates) */
if (ox == -VERYLARGE || oy == -VERYLARGE) {
*ex = ix;
*ey = iy;
if (ox == -VERYLARGE) {
/* can't get a direction to draw line, so simply
* return INRANGE point */
if (oy == -VERYLARGE)
return;
*ex = x_min;
return;
}
/* obviously oy is -VERYLARGE and ox != -VERYLARGE */
*ey = y_min;
return;
}
/*
* Can't have case (ix == ox && iy == oy) as one point
* is INRANGE and one point is OUTRANGE.
*/
if (iy == oy) {
/* horizontal line */
/* assume inrange(iy, y_min, y_max) */
*ey = iy; /* == oy */
if (inrange(x_max, ix, ox))
*ex = x_max;
else if (inrange(x_min, ix, ox))
*ex = x_min;
else {
graph_error("error in edge_intersect");
}
return;
} else if (ix == ox) {
/* vertical line */
/* assume inrange(ix, x_min, x_max) */
*ex = ix; /* == ox */
if (inrange(y_max, iy, oy))
*ey = y_max;
else if (inrange(y_min, iy, oy))
*ey = y_min;
else {
graph_error("error in edge_intersect");
}
return;
}
/* slanted line of some kind */
/* does it intersect y_min edge */
if (inrange(y_min, iy, oy) && y_min != iy && y_min != oy) {
x = ix + (y_min - iy) * ((ox - ix) / (oy - iy));
if (inrange(x, x_min, x_max)) {
*ex = x;
*ey = y_min;
return; /* yes */
}
}
/* does it intersect y_max edge */
if (inrange(y_max, iy, oy) && y_max != iy && y_max != oy) {
x = ix + (y_max - iy) * ((ox - ix) / (oy - iy));
if (inrange(x, x_min, x_max)) {
*ex = x;
*ey = y_max;
return; /* yes */
}
}
/* does it intersect x_min edge */
if (inrange(x_min, ix, ox) && x_min != ix && x_min != ox) {
y = iy + (x_min - ix) * ((oy - iy) / (ox - ix));
if (inrange(y, y_min, y_max)) {
*ex = x_min;
*ey = y;
return;
}
}
/* does it intersect x_max edge */
if (inrange(x_max, ix, ox) && x_max != ix && x_max != ox) {
y = iy + (x_max - ix) * ((oy - iy) / (ox - ix));
if (inrange(y, y_min, y_max)) {
*ex = x_max;
*ey = y;
return;
}
}
/* If we reach here, the inrange point is on the edge, and
* the line segment from the outrange point does not cross any
* other edges to get there. In this case, we return the inrange
* point as the 'edge' intersection point. This will basically draw
* line.
*/
*ex = ix;
*ey = iy;
return;
}
/* XXX - JG */
/* single edge intersection algorithm for "steps" curves */
/*
* Given two points, one inside and one outside the plot, return
* the point where an edge of the plot intersects the line segments
* forming the step between the two points.
*
* Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
* P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and
* (x2,y1)->(x2,y2).
*/
static void edge_intersect_steps(points, i, ex, ey)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *ex, *ey; /* the point where it crosses an edge */
{
/* global x_min, x_max, y_min, x_max */
double ax = points[i - 1].x;
double ay = points[i - 1].y;
double bx = points[i].x;
double by = points[i].y;
if (points[i].type == INRANGE) { /* from OUTRANGE to INRANG */
if (inrange(ay, y_min, y_max)) {
*ey = ay;
if (ax > x_max)
*ex = x_max;
else /* x < x_min */
*ex = x_min;
} else {
*ex = bx;
if (ay > y_max)
*ey = y_max;
else /* y < y_min */
*ey = y_min;
}
} else { /* from INRANGE to OUTRANGE */
if (inrange(bx, x_min, x_max)) {
*ex = bx;
if (by > y_max)
*ey = y_max;
else /* y < y_min */
*ey = y_min;
} else {
*ey = ay;
if (bx > x_max)
*ex = x_max;
else /* x < x_min */
*ex = x_min;
}
}
return;
}
/* XXX - HOE */
/* single edge intersection algorithm for "fsteps" curves */
/* fsteps means step on forward y-value.
* Given two points, one inside and one outside the plot, return
* the point where an edge of the plot intersects the line segments
* forming the step between the two points.
*
* Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
* P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and
* (x1,y2)->(x2,y2).
*/
static void edge_intersect_fsteps(points, i, ex, ey)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *ex, *ey; /* the point where it crosses an edge */
{
/* global x_min, x_max, y_min, x_max */
double ax = points[i - 1].x;
double ay = points[i - 1].y;
double bx = points[i].x;
double by = points[i].y;
if (points[i].type == INRANGE) { /* from OUTRANGE to INRANG */
if (inrange(ax, x_min, x_max)) {
*ex = ax;
if (ay > y_max)
*ey = y_max;
else /* y < y_min */
*ey = y_min;
} else {
*ey = by;
if (bx > x_max)
*ex = x_max;
else /* x < x_min */
*ex = x_min;
}
} else { /* from INRANGE to OUTRANGE */
if (inrange(by, y_min, y_max)) {
*ey = by;
if (bx > x_max)
*ex = x_max;
else /* x < x_min */
*ex = x_min;
} else {
*ex = ax;
if (by > y_max)
*ey = y_max;
else /* y < y_min */
*ey = y_min;
}
}
return;
}
/* XXX - JG */
/* double edge intersection algorithm for "steps" plot */
/* Given two points, both outside the plot, return the points where an
* edge of the plot intersects the line segments forming a step
* by the two points. There may be zero, one, two, or an infinite number
* of intersection points. (One means an intersection at a corner, infinite
* means overlaying the edge itself). We return FALSE when there is nothing
* to draw (zero intersections), and TRUE when there is something to
* draw (the one-point case is a degenerate of the two-point case and we do
* not distinguish it - we draw it anyway).
*
* Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
* P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and
* (x2,y1)->(x2,y2).
*/
static TBOOLEAN /* any intersection? */
two_edge_intersect_steps(points, i, lx, ly)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
{
/* global x_min, x_max, y_min, x_max */
double ax = points[i - 1].x;
double ay = points[i - 1].y;
double bx = points[i].x;
double by = points[i].y;
if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
((ay > y_max || ay < y_min) &&
(bx > x_max || bx < x_min))) {
return (FALSE);
} else if (inrange(ay, y_min, y_max) && inrange(bx, x_min, x_max)) { /* corner of step inside plotspace */
*ly++ = ay;
if (ax < x_min)
*lx++ = x_min;
else
*lx++ = x_max;
*lx++ = bx;
if (by < y_min)
*ly++ = y_min;
else
*ly++ = y_max;
return (TRUE);
} else if (inrange(ay, y_min, y_max)) { /* cross plotspace in x-direction */
*lx++ = x_min;
*ly++ = ay;
*lx++ = x_max;
*ly++ = ay;
return (TRUE);
} else if (inrange(ax, x_min, x_max)) { /* cross plotspace in y-direction */
*lx++ = bx;
*ly++ = y_min;
*lx++ = bx;
*ly++ = y_max;
return (TRUE);
} else
return (FALSE);
}
/* XXX - HOE */
/* double edge intersection algorithm for "fsteps" plot */
/* Given two points, both outside the plot, return the points where an
* edge of the plot intersects the line segments forming a step
* by the two points. There may be zero, one, two, or an infinite number
* of intersection points. (One means an intersection at a corner, infinite
* means overlaying the edge itself). We return FALSE when there is nothing
* to draw (zero intersections), and TRUE when there is something to
* draw (the one-point case is a degenerate of the two-point case and we do
* not distinguish it - we draw it anyway).
*
* Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from
* P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and
* (x1,y2)->(x2,y2).
*/
static TBOOLEAN /* any intersection? */
two_edge_intersect_fsteps(points, i, lx, ly)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
{
/* global x_min, x_max, y_min, x_max */
double ax = points[i - 1].x;
double ay = points[i - 1].y;
double bx = points[i].x;
double by = points[i].y;
if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
((by > y_max || by < y_min) &&
(ax > x_max || ax < x_min))) {
return (FALSE);
} else if (inrange(by, y_min, y_max) && inrange(ax, x_min, x_max)) { /* corner of step inside plotspace */
*lx++ = ax;
if (ay < y_min)
*ly++ = y_min;
else
*ly++ = y_max;
*ly = by;
if (bx < x_min)
*lx = x_min;
else
*lx = x_max;
return (TRUE);
} else if (inrange(by, y_min, y_max)) { /* cross plotspace in x-direction */
*lx++ = x_min;
*ly++ = by;
*lx = x_max;
*ly = by;
return (TRUE);
} else if (inrange(ax, x_min, x_max)) { /* cross plotspace in y-direction */
*lx++ = ax;
*ly++ = y_min;
*lx = ax;
*ly = y_max;
return (TRUE);
} else
return (FALSE);
}
/* double edge intersection algorithm */
/* Given two points, both outside the plot, return
* the points where an edge of the plot intersects the line segment defined
* by the two points. There may be zero, one, two, or an infinite number
* of intersection points. (One means an intersection at a corner, infinite
* means overlaying the edge itself). We return FALSE when there is nothing
* to draw (zero intersections), and TRUE when there is something to
* draw (the one-point case is a degenerate of the two-point case and we do
* not distinguish it - we draw it anyway).
*/
static TBOOLEAN /* any intersection? */
two_edge_intersect(points, i, lx, ly)
struct coordinate GPHUGE *points; /* the points array */
int i; /* line segment from point i-1 to point i */
double *lx, *ly; /* lx[2], ly[2]: points where it crosses edges */
{
/* global x_min, x_max, y_min, x_max */
int count;
double ix = points[i - 1].x;
double iy = points[i - 1].y;
double ox = points[i].x;
double oy = points[i].y;
double t[4];
double swap;
double t_min, t_max;
#if 0
fprintf(stderr, "\ntwo_edge_intersect (%g, %g) and (%g, %g) : ",
points[i - 1].x, points[i - 1].y,
points[i].x, points[i].y);
#endif
/* nasty degenerate cases, effectively drawing to an infinity point (?)
cope with them here, so don't process them as a "real" OUTRANGE point
If more than one coord is -VERYLARGE, then can't ratio the "infinities"
so drop out by returning FALSE */
count = 0;
if (ix == -VERYLARGE)
count++;
if (ox == -VERYLARGE)
count++;
if (iy == -VERYLARGE)
count++;
if (oy == -VERYLARGE)
count++;
/* either doesn't pass through graph area *or*
can't ratio infinities to get a direction to draw line, so simply return(FALSE) */
if (count > 1) {
#if 0
fprintf(stderr, "\tA\n");
#endif
return (FALSE);
}
if (ox == -VERYLARGE || ix == -VERYLARGE) {
if (ix == -VERYLARGE) {
/* swap points so ix/iy don't have a -VERYLARGE component */
swap = ix;
ix = ox;
ox = swap;
swap = iy;
iy = oy;
oy = swap;
}
/* check actually passes through the graph area */
if (ix > x_max && inrange(iy, y_min, y_max)) {
lx[0] = x_min;
ly[0] = iy;
lx[1] = x_max;
ly[1] = iy;
#if 0
fprintf(stderr, "(%g %g) -> (%g %g)",
lx[0], ly[0], lx[1], ly[1]);
#endif
return (TRUE);
} else {
#if 0
fprintf(stderr, "\tB\n");
#endif
return (FALSE);
}
}
if (oy == -VERYLARGE || iy == -VERYLARGE) {
if (iy == -VERYLARGE) {
/* swap points so ix/iy don't have a -VERYLARGE component */
swap = ix;
ix = ox;
ox = swap;
swap = iy;
iy = oy;
oy = swap;
}
/* check actually passes through the graph area */
if (iy > y_max && inrange(ix, x_min, x_max)) {
lx[0] = ix;
ly[0] = y_min;
lx[1] = ix;
ly[1] = y_max;
#if 0
fprintf(stderr, "(%g %g) -> (%g %g)",
lx[0], ly[0], lx[1], ly[1]);
#endif
return (TRUE);
} else {
#if 0
fprintf(stderr, "\tC\n");
#endif
return (FALSE);
}
}
/*
* Special horizontal/vertical, etc. cases are checked and remaining
* slant lines are checked separately.
*
* The slant line intersections are solved using the parametric form
* of the equation for a line, since if we test x/y min/max planes explicitly
* then e.g. a line passing through a corner point (x_min,y_min)
* actually intersects 2 planes and hence further tests would be required
* to anticipate this and similar situations.
*/
/*
* Can have case (ix == ox && iy == oy) as both points OUTRANGE
*/
if (ix == ox && iy == oy) {
/* but as only define single outrange point, can't intersect graph area */
return (FALSE);
}
if (ix == ox) {
/* line parallel to y axis */
/* x coord must be in range, and line must span both y_min and y_max */
/* note that spanning y_min implies spanning y_max, as both points OUTRANGE */
if (!inrange(ix, x_min, x_max)) {
return (FALSE);
}
if (inrange(y_min, iy, oy)) {
lx[0] = ix;
ly[0] = y_min;
lx[1] = ix;
ly[1] = y_max;
#if 0
fprintf(stderr, "(%g %g) -> (%g %g)",
lx[0], ly[0], lx[1], ly[1]);
#endif
return (TRUE);
} else
return (FALSE);
}
if (iy == oy) {
/* already checked case (ix == ox && iy == oy) */
/* line parallel to x axis */
/* y coord must be in range, and line must span both x_min and x_max */
/* note that spanning x_min implies spanning x_max, as both points OUTRANGE */
if (!inrange(iy, y_min, y_max)) {
return (FALSE);
}
if (inrange(x_min, ix, ox)) {
lx[0] = x_min;
ly[0] = iy;
lx[1] = x_max;
ly[1] = iy;
#if 0
fprintf(stderr, "(%g %g) -> (%g %g)",
lx[0], ly[0], lx[1], ly[1]);
#endif
return (TRUE);
} else
return (FALSE);
}
/* nasty 2D slanted line in an xy plane */
/*
Solve parametric equation
(ix, iy) + t (diff_x, diff_y)
where 0.0 <= t <= 1.0 and
diff_x = (ox - ix);
diff_y = (oy - iy);
*/
t[0] = (x_min - ix) / (ox - ix);
t[1] = (x_max - ix) / (ox - ix);
if (t[0] > t[1]) {
swap = t[0];
t[0] = t[1];
t[1] = swap;
}
t[2] = (y_min - iy) / (oy - iy);
t[3] = (y_max - iy) / (oy - iy);
if (t[2] > t[3]) {
swap = t[2];
t[2] = t[3];
t[3] = swap;
}
t_min = GPMAX(GPMAX(t[0], t[2]), 0.0);
t_max = GPMIN(GPMIN(t[1], t[3]), 1.0);
if (t_min > t_max)
return (FALSE);
lx[0] = ix + t_min * (ox - ix);
ly[0] = iy + t_min * (oy - iy);
lx[1] = ix + t_max * (ox - ix);
ly[1] = iy + t_max * (oy - iy);
/*
* Can only have 0 or 2 intersection points -- only need test one coord
*/
if (inrange(lx[0], x_min, x_max) &&
inrange(ly[0], y_min, y_max)) {
#if 0
fprintf(stderr, "(%g %g) -> (%g %g)",
lx[0], ly[0], lx[1], ly[1]);
#endif
return (TRUE);
}
return (FALSE);
}
/* justify ticplace to a proper date-time value */
double time_tic_just(level, ticplace)
int level;
double ticplace;
{
struct tm tm;
if (level <= 0) {
return (ticplace);
}
ggmtime(&tm, (double) ticplace);
if (level > 0) { /* units of minutes */
if (tm.tm_sec > 50)
tm.tm_min++;
tm.tm_sec = 0;
}
if (level > 1) { /* units of hours */
if (tm.tm_min > 50)
tm.tm_hour++;
tm.tm_min = 0;
}
if (level > 2) { /* units of days */
if (tm.tm_hour > 14) {
tm.tm_hour = 0;
tm.tm_mday = 0;
tm.tm_yday++;
ggmtime(&tm, (double) gtimegm(&tm));
} else if (tm.tm_hour > 7) {
tm.tm_hour = 12;
} else if (tm.tm_hour > 3) {
tm.tm_hour = 6;
} else {
tm.tm_hour = 0;
}
}
/* skip it, I have not bothered with weekday so far */
if (level > 4) { /* units of month */
if (tm.tm_mday > 25) {
tm.tm_mon++;
if (tm.tm_mon > 11) {
tm.tm_year++;
tm.tm_mon = 0;
}
}
tm.tm_mday = 1;
}
if (level > 5) {
if (tm.tm_mon >= 7)
tm.tm_year++;
tm.tm_mon = 0;
}
ticplace = (double) gtimegm(&tm);
ggmtime(&tm, (double) gtimegm(&tm));
return (ticplace);
}
/* make smalltics for time-axis */
double make_ltic(tlevel, incr)
int tlevel;
double incr;
{
double tinc;
tinc = 0;
if (tlevel < 0)
tlevel = 0;
switch (tlevel) {
case 0:
case 1:{
if (incr >= 20)
tinc = 10;
if (incr >= 60)
tinc = 30;
if (incr >= 2 * 60)
tinc = 60;
if (incr >= 5 * 60)
tinc = 2 * 60;
if (incr >= 10 * 60)
tinc = 5 * 60;
if (incr >= 20 * 60)
tinc = 10 * 60;
break;
}
case 2:{
if (incr >= 20 * 60)
tinc = 10 * 60;
if (incr >= 3600)
tinc = 30 * 60;
if (incr >= 2 * 3600)
tinc = 3600;
if (incr >= 5 * 3600)
tinc = 2 * 3600;
if (incr >= 10 * 3600)
tinc = 5 * 3600;
if (incr >= 20 * 3600)
tinc = 10 * 3600;
break;
}
case 3:{
if (incr > 2 * 3600)
tinc = 3600;
if (incr > 4 * 3600)
tinc = 2 * 3600;
if (incr > 7 * 3600)
tinc = 3 * 3600;
if (incr > 13 * 3600)
tinc = 6 * 3600;
if (incr > DAY_SEC)
tinc = 12 * 3600;
if (incr > 2 * DAY_SEC)
tinc = DAY_SEC;
break;
}
case 4:{ /* week: tic per day */
if (incr > 2 * DAY_SEC)
tinc = DAY_SEC;
if (incr > 7 * DAY_SEC)
tinc = 7 * DAY_SEC;
break;
}
case 5:{ /* month */
if (incr > 2 * DAY_SEC)
tinc = DAY_SEC;
if (incr > 15 * DAY_SEC)
tinc = 10 * DAY_SEC;
if (incr > 2 * MON_SEC)
tinc = MON_SEC;
if (incr > 6 * MON_SEC)
tinc = 3 * MON_SEC;
if (incr > 2 * YEAR_SEC)
tinc = YEAR_SEC;
break;
}
case 6:{ /* year */
if (incr > 2 * MON_SEC)
tinc = MON_SEC;
if (incr > 6 * MON_SEC)
tinc = 3 * MON_SEC;
if (incr > 2 * YEAR_SEC)
tinc = YEAR_SEC;
if (incr > 10 * YEAR_SEC)
tinc = 5 * YEAR_SEC;
if (incr > 50 * YEAR_SEC)
tinc = 10 * YEAR_SEC;
if (incr > 100 * YEAR_SEC)
tinc = 20 * YEAR_SEC;
if (incr > 200 * YEAR_SEC)
tinc = 50 * YEAR_SEC;
if (incr > 300 * YEAR_SEC)
tinc = 100 * YEAR_SEC;
break;
}
}
return (tinc);
}
void write_multiline(x, y, text, hor, vert, angle, font)
unsigned int x, y;
char *text;
enum JUSTIFY hor; /* horizontal ... */
int vert; /* ... and vertical just - text in hor direction despite angle */
int angle; /* assume term has already been set for this */
char *font; /* NULL or "" means use default */
{
register struct termentry *t = term;
char *p = text;
if (!p)
return;
if (vert != JUST_TOP) {
/* count lines and adjust y */
int lines = 0; /* number of linefeeds - one fewer than lines */
while (*p++) {
if (*p == '\n')
++lines;
}
if (angle)
x -= (vert * lines * t->v_char) / 2;
else
y += (vert * lines * t->v_char) / 2;
}
if (font && *font)
(*t->set_font) (font);
for (;;) { /* we will explicitly break out */
if ((text != NULL) && (p = strchr(text, '\n')) != NULL)
*p = 0; /* terminate the string */
if ((*t->justify_text) (hor)) {
(*t->put_text) (x, y, text);
} else {
int fix = hor * (t->h_char) * strlen(text) / 2;
if (angle)
(*t->put_text) (x, y - fix, text);
else
(*t->put_text) (x - fix, y, text);
}
if (angle)
x += t->v_char;
else
y -= t->v_char;
if (!p)
break;
else {
/* put it back */
*p = '\n';
}
text = p + 1;
} /* unconditional branch back to the for(;;) - just a goto ! */
if (font && *font)
(*t->set_font) (default_font);
}
/* display a x-axis ticmark - called by gen_ticks */
/* also uses global tic_start, tic_direction, tic_text and tic_just */
static void xtick2d_callback(axis, place, text, grid)
int axis;
double place;
char *text;
struct lp_style_type grid; /* linetype or -2 for no grid */
{
register struct termentry *t = term;
/* minitick if text is NULL - beware - h_tic is unsigned */
int ticsize = tic_direction * (int) (t->v_tic) * (text ? ticscale : miniticscale);
unsigned int x = map_x(place);
if (grid.l_type > -2) {
term_apply_lp_properties(&grid);
if (polar_grid_angle) {
double x = place, y = 0, s = sin(0.1), c = cos(0.1);
int i;
int ogx = map_x(x);
int ogy = map_y(0);
int tmpgx, tmpgy, gx, gy;
if (place > largest_polar_circle)
largest_polar_circle = place;
else if (-place > largest_polar_circle)
largest_polar_circle = -place;
for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
{
/* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
double tx = x * c - y * s;
/* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
y = y * c + x * s;
x = tx;
}
tmpgx = gx = map_x(x);
tmpgy = gy = map_y(y);
if (clip_line(&ogx, &ogy, &tmpgx, &tmpgy)) {
(*t->move) ((unsigned int) ogx, (unsigned int) ogy);
(*t->vector) ((unsigned int) tmpgx, (unsigned int) tmpgy);
}
ogx = gx;
ogy = gy;
}
} else {
if (lkey && key_yt > ybot && x < key_xr && x > key_xl) {
if (key_yb > ybot) {
(*t->move) (x, ybot);
(*t->vector) (x, key_yb);
}
if (key_yt < ytop) {
(*t->move) (x, key_yt);
(*t->vector) (x, ytop);
}
} else {
(*t->move) (x, ybot);
(*t->vector) (x, ytop);
}
}
term_apply_lp_properties(&border_lp); /* border linetype */
}
/* we precomputed tic posn and text posn in global vars */
(*t->move) (x, tic_start);
(*t->vector) (x, tic_start + ticsize);
if (tic_mirror >= 0) {
(*t->move) (x, tic_mirror);
(*t->vector) (x, tic_mirror - ticsize);
}
if (text)
write_multiline(x, tic_text, text, tic_hjust, tic_vjust, rotate_tics, NULL);
}
/* display a y-axis ticmark - called by gen_ticks */
/* also uses global tic_start, tic_direction, tic_text and tic_just */
static void ytick2d_callback(axis, place, text, grid)
int axis;
double place;
char *text;
struct lp_style_type grid; /* linetype or -2 */
{
register struct termentry *t = term;
/* minitick if text is NULL - v_tic is unsigned */
int ticsize = tic_direction * (int) (t->h_tic) * (text ? ticscale : miniticscale);
unsigned int y = map_y(place);
if (grid.l_type > -2) {
term_apply_lp_properties(&grid);
if (polar_grid_angle) {
double x = 0, y = place, s = sin(0.1), c = cos(0.1);
int i;
if (place > largest_polar_circle)
largest_polar_circle = place;
else if (-place > largest_polar_circle)
largest_polar_circle = -place;
clip_move(map_x(x), map_y(y));
for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
{
/* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
double tx = x * c - y * s;
/* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
y = y * c + x * s;
x = tx;
}
clip_vector(map_x(x), map_y(y));
}
} else {
if (lkey && y < key_yt && y > key_yb && key_xl < xright /* catch TOUT */ ) {
if (key_xl > xleft) {
(*t->move) (xleft, y);
(*t->vector) (key_xl, y);
}
if (key_xr < xright) {
(*t->move) (key_xr, y);
(*t->vector) (xright, y);
}
} else {
(*t->move) (xleft, y);
(*t->vector) (xright, y);
}
}
term_apply_lp_properties(&border_lp); /* border linetype */
}
/* we precomputed tic posn and text posn */
(*t->move) (tic_start, y);
(*t->vector) (tic_start + ticsize, y);
if (tic_mirror >= 0) {
(*t->move) (tic_mirror, y);
(*t->vector) (tic_mirror - ticsize, y);
}
if (text)
write_multiline(tic_text, y, text, tic_hjust, tic_vjust, rotate_tics, NULL);
}
int label_width(str, lines)
char *str;
int *lines;
{
char lab[MAX_LINE_LEN + 1], *s, *e;
int mlen, len, l;
l = mlen = len = 0;
sprintf(lab, "%s\n", str);
s = lab;
while ((e = (char *) strchr(s, '\n')) != NULL) { /* HBB 980308: quiet BC-3.1 warning */
*e = '\0';
len = strlen(s); /* = e-s ? */
if (len > mlen)
mlen = len;
if (len || l)
l++;
s = ++e;
}
/* lines = NULL => not interested - div */
if (lines)
*lines = l;
return (mlen);
}
void setup_tics(axis, ticdef, format, max)
int axis;
struct ticdef *ticdef;
char *format;
int max; /* approx max number of slots available */
{
double tic = 0; /* HBB: shut up gcc -Wall */
int fixmin = (auto_array[axis] & 1) != 0;
int fixmax = (auto_array[axis] & 2) != 0;
if (ticdef->type == TIC_SERIES) {
ticstep[axis] = tic = ticdef->def.series.incr;
fixmin &= (ticdef->def.series.start == -VERYLARGE);
fixmax &= (ticdef->def.series.end == VERYLARGE);
} else if (ticdef->type == TIC_COMPUTED) {
ticstep[axis] = tic = make_tics(axis, max);
} else {
fixmin = fixmax = 0; /* user-defined, day or month */
}
if (fixmin) {
if (min_array[axis] < max_array[axis])
min_array[axis] = tic * floor(min_array[axis] / tic);
else
min_array[axis] = tic * ceil(min_array[axis] / tic);
}
if (fixmax) {
if (min_array[axis] < max_array[axis])
max_array[axis] = tic * ceil(max_array[axis] / tic);
else
max_array[axis] = tic * floor(max_array[axis] / tic);
}
if (datatype[axis] == TIME && format_is_numeric[axis])
/* invent one for them */
timetic_format(axis, min_array[axis], max_array[axis]);
else
strcpy(ticfmt[axis], format);
}
/*{{{ mant_exp - split into mantissa and/or exponent */
static void mant_exp(log_base, x, scientific, m, p)
double log_base, x;
int scientific; /* round to power of 3 */
double *m;
int *p; /* results */
{
int sign = 1;
double l10;
int power;
/*{{{ check 0 */
if (x == 0) {
if (m)
*m = 0;
if (p)
*p = 0;
return;
}
/*}}} */
/*{{{ check -ve */
if (x < 0) {
sign = (-1);
x = (-x);
}
/*}}} */
l10 = log10(x) / log_base;
power = floor(l10);
if (scientific) {
power = 3 * floor(power / 3.0);
}
if (m)
*m = sign * pow(10.0, (l10 - power) * log_base);
if (p)
*p = power;
}
/*}}} */
/*
* Kludge alert!!
* Workaround until we have a better solution ...
* Note: this assumes that all calls to sprintf in gprintf have
* exactly three args. Lars
*/
#ifdef HAVE_SNPRINTF
# define sprintf(str,fmt,arg) \
if (snprintf((str),count,(fmt),(arg)) > count) \
fprintf (stderr,"%s:%d: Warning: too many digits for format\n",__FILE__,__LINE__)
#endif
/*{{{ gprintf */
/* extended snprintf */
static void gprintf(dest, count, format, log_base, x)
char *dest, *format;
size_t count;
double log_base, x; /* we print one number in a number of different formats */
{
#define LOC_PI 3.14159265358979323846 /* local definition of PI */
char temp[MAX_LINE_LEN];
char *t;
for (;;) {
/*{{{ copy to dest until % */
while (*format != '%')
if (!(*dest++ = *format++))
return; /* end of format */
/*}}} */
/*{{{ check for %% */
if (format[1] == '%') {
*dest++ = '%';
format += 2;
continue;
}
/*}}} */
/*{{{ copy format part to temp, excluding conversion character */
t = temp;
*t++ = '%';
/* dont put isdigit first since sideeffect in macro is bad */
while (*++format == '.' || isdigit((int) *format) ||
*format == '-' || *format == '+' || *format == ' ')
*t++ = *format;
/*}}} */
/*{{{ convert conversion character */
switch (*format) {
/*{{{ x and o */
case 'x':
case 'X':
case 'o':
case 'O':
t[0] = *format++;
t[1] = 0;
sprintf(dest, temp, (int) x);
dest += strlen(dest);
break;
/*}}} */
/*{{{ e, f and g */
case 'e':
case 'E':
case 'f':
case 'F':
case 'g':
case 'G':
t[0] = *format++;
t[1] = 0;
sprintf(dest, temp, x);
dest += strlen(dest);
break;
/*}}} */
/*{{{ l */
case 'l':
{
double mantissa;
mant_exp(log_base, x, 0, &mantissa, NULL);
t[0] = 'f';
t[1] = 0;
sprintf(dest, temp, mantissa);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ t */
case 't':
{
double mantissa;
mant_exp(1.0, x, 0, &mantissa, NULL);
t[0] = 'f';
t[1] = 0;
sprintf(dest, temp, mantissa);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ s */
case 's':
{
double mantissa;
mant_exp(1.0, x, 1, &mantissa, NULL);
t[0] = 'f';
t[1] = 0;
sprintf(dest, temp, mantissa);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ L */
case 'L':
{
int power;
mant_exp(log_base, x, 0, NULL, &power);
t[0] = 'd';
t[1] = 0;
sprintf(dest, temp, power);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ T */
case 'T':
{
int power;
mant_exp(1.0, x, 0, NULL, &power);
t[0] = 'd';
t[1] = 0;
sprintf(dest, temp, power);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ S */
case 'S':
{
int power;
mant_exp(1.0, x, 1, NULL, &power);
t[0] = 'd';
t[1] = 0;
sprintf(dest, temp, power);
dest += strlen(dest);
++format;
break;
}
/*}}} */
/*{{{ c */
case 'c':
{
int power;
mant_exp(1.0, x, 1, NULL, &power);
t[0] = 'c';
t[1] = 0;
power = power / 3 + 6; /* -18 -> 0, 0 -> 6, +18 -> 12, ... */
if (power >= 0 && power <= 12) {
sprintf(dest, temp, "afpnum kMGTPE"[power]);
} else {
/* please extend the range ! */
/* name power name power
-------------------------
atto -18 Exa 18
femto -15 Peta 15
pico -12 Tera 12
nano -9 Giga 9
micro -6 Mega 6
milli -3 kilo 3 */
/* for the moment, print e+21 for example */
sprintf(dest, "e%+02d", (power - 6) * 3);
}
dest += strlen(dest);
++format;
break;
}
case 'P':
{
t[0] = 'f';
t[1] = 0;
sprintf(dest, temp, x / LOC_PI);
dest += strlen(dest);
++format;
break;
}
/*}}} */
default:
int_error("Bad format character", NO_CARET);
}
/*}}} */
}
}
#undef LOC_PI /* local definition of PI */
/*}}} */
#ifdef HAVE_SNPRINTF
# undef sprintf
#endif
/*{{{ gen_tics */
/* uses global arrays ticstep[], ticfmt[], min_array[], max_array[],
* auto_array[], log_array[], log_base_array[]
* we use any of GRID_X/Y/X2/Y2 and _MX/_MX2/etc - caller is expected
* to clear the irrelevent fields from global grid bitmask
* note this is also called from graph3d, so we need GRID_Z too
*/
void gen_tics(axis, def, grid, minitics, minifreq, callback)
int axis; /* FIRST_X_AXIS, etc */
struct ticdef *def; /* tic defn */
int grid; /* GRID_X | GRID_MX etc */
int minitics; /* minitics - off/default/auto/explicit */
double minifreq; /* frequency */
tic_callback callback; /* fn to call to actually do the work */
{
/* seperate main-tic part of grid */
struct lp_style_type lgrd, mgrd;
memcpy(&lgrd, &grid_lp, sizeof(struct lp_style_type));
memcpy(&mgrd, &mgrid_lp, sizeof(struct lp_style_type));
lgrd.l_type = (grid & (GRID_X | GRID_Y | GRID_X2 | GRID_Y2 | GRID_Z)) ? grid_lp.l_type : -2;
mgrd.l_type = (grid & (GRID_MX | GRID_MY | GRID_MX2 | GRID_MY2 | GRID_MZ)) ? mgrid_lp.l_type : -2;
if (def->type == TIC_USER) { /* special case */
/*{{{ do user tics then return */
struct ticmark *mark = def->def.user;
double uncertain = (max_array[axis] - min_array[axis]) / 10;
double ticmin = min_array[axis] - SIGNIF * uncertain;
double internal_max = max_array[axis] + SIGNIF * uncertain;
double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
/* polar labels always +ve, and if rmin has been set, they are
* relative to rmin. position is as user specified, but must
* be translated. I dont think it will work at all for
* log scale, so I shan't worry about it !
*/
double polar_shift = (polar && !(autoscale_r & 1)) ? rmin : 0;
for (mark = def->def.user; mark; mark = mark->next) {
char label[64];
double internal = log_array[axis] ? log(mark->position) / log_base_array[axis] : mark->position;
internal -= polar_shift;
if (!inrange(internal, ticmin, internal_max))
continue;
if (datatype[axis] == TIME)
gstrftime(label, 24, mark->label ? mark->label : ticfmt[axis], mark->position);
else
gprintf(label, sizeof(label), mark->label ? mark->label : ticfmt[axis], log_base, mark->position);
(*callback) (axis, internal, label, lgrd);
}
return; /* NO MINITICS FOR USER-DEF TICS */
/*}}} */
}
/* series-tics
* need to distinguish user co-ords from internal co-ords.
* - for logscale, internal = log(user), else internal = user
*
* The minitics are a bit of a drag - we need to distinuish
* the cases step>1 from step == 1.
* If step = 1, we are looking at 1,10,100,1000 for example, so
* minitics are 2,5,8, ... - done in user co-ordinates
* If step>1, we are looking at 1,1e6,1e12 for example, so
* minitics are 10,100,1000,... - done in internal co-ords
*/
{
double tic; /* loop counter */
double internal; /* in internal co-ords */
double user; /* in user co-ords */
double start, step, end;
double lmin = min_array[axis], lmax = max_array[axis];
double internal_min, internal_max; /* to allow for rounding errors */
double ministart = 0, ministep = 1, miniend = 1; /* internal or user - depends on step */
int anyticput = 0; /* for detection of infinite loop */
/* gprintf uses log10() of base - log_base_array is log() */
double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
if (lmax < lmin) {
/* hmm - they have set reversed range for some reason */
double temp = lmin;
lmin = lmax;
lmax = temp;
}
/*{{{ choose start, step and end */
switch (def->type) {
case TIC_SERIES:
if (log_array[axis]) {
/* we can tolerate start <= 0 if step and end > 0 */
if (def->def.series.end <= 0 ||
def->def.series.incr <= 0)
return; /* just quietly ignore */
step = log(def->def.series.incr) / log_base_array[axis];
end = log(def->def.series.end) / log_base_array[axis];
start = def->def.series.start > 0 ?
log(def->def.series.start) / log_base_array[axis] :
step;
} else {
start = def->def.series.start;
step = def->def.series.incr;
end = def->def.series.end;
if (start == -VERYLARGE)
start = step * floor(lmin / step);
if (end == VERYLARGE)
end = step * ceil(lmax / step);
}
break;
case TIC_COMPUTED:
/* round to multiple of step */
start = ticstep[axis] * floor(lmin / ticstep[axis]);
step = ticstep[axis];
end = ticstep[axis] * ceil(lmax / ticstep[axis]);
break;
case TIC_MONTH:
start = floor(lmin);
end = ceil(lmax);
step = floor((end - start) / 12);
if (step < 1)
step = 1;
break;
case TIC_DAY:
start = floor(lmin);
end = ceil(lmax);
step = floor((end - start) / 14);
if (step < 1)
step = 1;
break;
default:
graph_error("Internal error : unknown tic type");
return; /* avoid gcc -Wall warning about start */
}
/*}}} */
/*{{{ ensure ascending order */
if (end < start) {
double temp;
temp = end;
end = start;
start = temp;
}
step = fabs(step);
/*}}} */
if (minitics) {
/*{{{ figure out ministart, ministep, miniend */
if (minitics == MINI_USER) {
/* they have said what they want */
if (minifreq <= 0)
minitics = 0; /* not much else we can do */
else if (log_array[axis]) {
ministart = ministep = step / minifreq * base_array[axis];
miniend = step * base_array[axis];
} else {
ministart = ministep = step / minifreq;
miniend = step;
}
} else if (log_array[axis]) {
if (step > 1.5) { /* beware rounding errors */
/*{{{ 10,100,1000 case */
/* no more than five minitics */
ministart = ministep = (int) (0.2 * step);
if (ministep < 1)
ministart = ministep = 1;
miniend = step;
/*}}} */
} else {
/*{{{ 2,5,8 case */
miniend = base_array[axis];
if (end - start >= 10)
minitics = 0; /* none */
else if (end - start >= 5) {
ministart = 2;
ministep = 3;
} else {
ministart = 2;
ministep = 1;
}
/*}}} */
}
} else if (datatype[axis] == TIME) {
ministart = ministep = make_ltic(timelevel[axis], step);
miniend = step * 0.9;
} else if (minitics == MINI_AUTO) {
ministart = ministep = 0.1 * step;
miniend = step;
} else
minitics = 0;
if (ministep <= 0)
minitics = 0; /* dont get stuck in infinite loop */
/*}}} */
}
/*{{{ a few tweaks and checks */
/* watch rounding errors */
end += SIGNIF * step;
internal_max = lmax + step * SIGNIF;
internal_min = lmin - step * SIGNIF;
if (step == 0)
return; /* just quietly ignore them ! */
/*}}} */
for (tic = start; tic <= end; tic += step) {
if (anyticput == 2) /* See below... */
break;
if (anyticput && (fabs(tic - start) < DBL_EPSILON)) {
/* step is too small.. */
anyticput = 2; /* Don't try again. */
tic = end; /* Put end tic. */
} else
anyticput = 1;
/*{{{ calc internal and user co-ords */
if (!log_array[axis]) {
internal = datatype[axis] == TIME ? time_tic_just(timelevel[axis], tic) : tic;
user = CheckZero(internal, step);
} else {
/* log scale => dont need to worry about zero ? */
internal = tic;
user = pow(base_array[axis], internal);
}
/*}}} */
if (internal > internal_max)
break; /* gone too far - end of series = VERYLARGE perhaps */
if (internal >= internal_min) {
/* continue; *//* maybe minitics!!!. user series starts below min ? */
/*{{{ draw tick via callback */
switch (def->type) {
case TIC_DAY:{
int d = (long) floor(user + 0.5) % 7;
if (d < 0)
d += 7;
(*callback) (axis, internal, abbrev_day_names[d], lgrd);
break;
}
case TIC_MONTH:{
int m = (long) floor(user - 1) % 12;
if (m < 0)
m += 12;
(*callback) (axis, internal, abbrev_month_names[m], lgrd);
break;
}
default:{ /* comp or series */
char label[64];
if (datatype[axis] == TIME) {
/* If they are doing polar time plot, good luck to them */
gstrftime(label, 24, ticfmt[axis], (double) user);
} else if (polar) {
/* if rmin is set, we stored internally with r-rmin */
/* Igor's polar-grid patch */
#if 1
/* HBB 990327: reverted to 'pre-Igor' version... */
double r = fabs(user) + (autoscale_r & 1 ? 0 : rmin);
#else
/* Igor removed fabs to allow -ve labels */
double r = user + (autoscale_r & 1 ? 0 : rmin);
#endif
gprintf(label, sizeof(label), ticfmt[axis], log_base, r);
} else {
gprintf(label, sizeof(label), ticfmt[axis], log_base, user);
}
(*callback) (axis, internal, label, lgrd);
}
}
/*}}} */
}
if (minitics) {
/*{{{ process minitics */
double mplace, mtic;
for (mplace = ministart; mplace < miniend; mplace += ministep) {
if (datatype[axis] == TIME)
mtic = time_tic_just(timelevel[axis] - 1, internal + mplace);
else
mtic = internal + (log_array[axis] && step <= 1.5 ? log(mplace) / log_base_array[axis] : mplace);
if (inrange(mtic, internal_min, internal_max) &&
inrange(mtic, start - step * SIGNIF, end + step * SIGNIF))
(*callback) (axis, mtic, NULL, mgrd);
}
/*}}} */
}
}
}
}
/*}}} */
/*{{{ map_position */
static void map_position(pos, x, y, what)
struct position *pos;
unsigned int *x, *y;
char *what;
{
switch (pos->scalex) {
case first_axes:
{
double xx = LogScale(pos->x, log_array[FIRST_X_AXIS], log_base_array[FIRST_X_AXIS], what, "x");
*x = xleft + (xx - min_array[FIRST_X_AXIS]) * scale[FIRST_X_AXIS] + 0.5;
break;
}
case second_axes:
{
double xx = LogScale(pos->x, log_array[SECOND_X_AXIS], log_base_array[SECOND_X_AXIS], what, "x");
*x = xleft + (xx - min_array[SECOND_X_AXIS]) * scale[SECOND_X_AXIS] + 0.5;
break;
}
case graph:
{
*x = xleft + pos->x * (xright - xleft) + 0.5;
break;
}
case screen:
{
register struct termentry *t = term;
*x = pos->x * (t->xmax) + 0.5;
break;
}
}
switch (pos->scaley) {
case first_axes:
{
double yy = LogScale(pos->y, log_array[FIRST_Y_AXIS], log_base_array[FIRST_Y_AXIS], what, "y");
*y = ybot + (yy - min_array[FIRST_Y_AXIS]) * scale[FIRST_Y_AXIS] + 0.5;
return;
}
case second_axes:
{
double yy = LogScale(pos->y, log_array[SECOND_Y_AXIS], log_base_array[SECOND_Y_AXIS], what, "y");
*y = ybot + (yy - min_array[SECOND_Y_AXIS]) * scale[SECOND_Y_AXIS] + 0.5;
return;
}
case graph:
{
*y = ybot + pos->y * (ytop - ybot) + 0.5;
return;
}
case screen:
{
register struct termentry *t = term;
*y = pos->y * (t->ymax) + 0.5;
return;
}
}
}
/*}}} */
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to graphics.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot