/* file: axis.c Paul Albrecht September 1984
Last revised: 14 November 2002
Axis and grid functions for plt
Copyright (C) Paul Albrecht 1988
Recent changes (by George Moody, george@mit.edu):
12 April 2001: "-g ygrid -s x" now works; general cleanup
21 October 2002: moved formerly global variables here from plt.h
14 November 2002: fixed missing cast in azmem call
_______________________________________________________________________________
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
You may contact the maintainer by e-mail (george@mit.edu) or postal mail
(MIT Room E25-505A, Cambridge, MA 02139 USA). For updates to this software,
please visit PhysioNet (http://www.physionet.org/).
_______________________________________________________________________________
*/
#include "plt.h"
#define NO_TICK 0
#define IN_OUT_TICK 01
#define IN_TICK 02
#define OUT_TICK 03
#define IN_OUT_MASK 03
#define GRID 04
#define SYMMETRIC 010
#define SUB_GRID 020
#define XGRID 040
#define YGRID 0100
typedef struct {
AxisPtr a;
double tick;
double scl;
char *lbl;
} *TickPtr;
static int gtype = OUT_TICK;
/* Prototypes of functions defined in this module */
void SetupAxes(void);
void AxisInit(Mode mode);
void XAxisDraw(void);
void YAxisDraw(void);
void TickDef(AxisPtr a, double tick, char *lbl, double scl, Boolean override);
static void AxisInitOne(AxisPtr a);
static void MinmaxSetup(AxisPtr a);
static void AxisSetup(AxisPtr a, AxisPtr oa);
static void LinearTickSetup(AxisPtr a);
static void LogTickSetup(AxisPtr a);
static void GridSetup(void);
static void GridDraw(AxisPtr a, AxisPtr oa);
static Ptype TickDrawAxis(AxisPtr a);
static int TickDraw(TickPtr t, Ptype ticklen);
static void TickLabel(TickPtr t, int off);
/* Public functions */
void SetupAxes(void)
{
char xtitle[200];
xwmin = p->xfull * ((xwmins == DEFAULT) ? p->xwmins : xwmins);
xwmax = p->xfull * ((xwmaxs == DEFAULT) ? p->xwmaxs : xwmaxs);
ywmin = p->yfull * ((ywmins == DEFAULT) ? p->ywmins : ywmins);
ywmax = p->yfull * ((ywmaxs == DEFAULT) ? p->ywmaxs : ywmaxs);
xfract = (double)(xwmax - xwmin)/p->xfull/(p->xwmaxs-p->xwmins);
yfract = (double)(ywmax - ywmin)/p->yfull/(p->ywmaxs-p->ywmins);
if (xfract > yfract) yfract = 0.1*xfract + 0.9*yfract;
else xfract = 0.9*xfract + 0.1*yfract;
MinmaxSetup(&xa);
MinmaxSetup(&ya);
xa.scl = (xwmax-xwmin)/(xa.max-xa.min);
xa.off = xwmin - xa.min*xa.scl + 0.5;
ya.scl = (ywmax-ywmin)/(ya.max-ya.min);
ya.off = ywmin - ya.min*ya.scl + 0.5;
AxisSetup(&xa, &ya);
AxisSetup(&ya, &xa);
GridSetup();
if (xa.lbl == 0) {
sprintf(xtitle, "%sX is %.5g to %.5g, %sY is %.5g to %.5g",
xa.logflg ? "Log " : "", xmin, xmax,
ya.logflg ? "Log " : "", ymin, ymax);
xa.lbl = StringSave(xtitle);
}
}
void AxisInit(Mode mode)
{
xa.name = 'x';
AxisInitOne(&xa);
ya.name = 'y';
AxisInitOne(&ya);
xmin = ymin = FHUGE;
xmax = ymax = -FHUGE;
xwmins = xwmaxs = ywmins = ywmaxs = FDEFAULT;
gridfg = "P12,W.1,Ldot";
gridtype = "out";
}
void XAxisDraw(void)
{
Ptype min, max, off, off2, xsize, ysize;
if ((gtype & (GRID|XGRID)) && (xa.mode & GRIDMARKS))
GridDraw(&xa, &ya);
FontGroupSelect("a", xa.numfg);
if (xa.mode & AXIS) {
min = X(xa.min);
max = X(xa.max);
line(min, xa.lo, max, xa.lo);
if (gtype & SYMMETRIC)
line(min, xa.hi, max, xa.hi);
}
off = TickDrawAxis(&xa);
if (xa.lbl && (xa.mode & TITLES)) {
strsize(xa.lbl, &xsize, &ysize, 0.0);
off2 = yfract*(yinch/4 + ysize/2) - ysize/3;
off -= xa.rev ? -off2 : off2;
FontGroupSelect("t", xa.lblfg);
alabel(xa.rev ? "XTR" : "XT", xa.lbl, (xwmin+xwmax)/2, off);
}
}
void YAxisDraw(void)
{
Ptype min, max, off, off2, xsize, ysize;
if ((gtype & (GRID|YGRID)) && (ya.mode & GRIDMARKS))
GridDraw(&ya, &xa);
FontGroupSelect("a", ya.numfg);
if (ya.mode & AXIS) {
min = Y(ya.min);
max = Y(ya.max);
line(ya.lo, min, ya.lo, max);
if (gtype & SYMMETRIC)
line( ya.hi, min, ya.hi, max);
}
off = TickDrawAxis(&ya);
if (ya.lbl && (ya.mode & TITLES)) {
strsize(ya.lbl, &xsize, &ysize, 90.0);
off2 = xfract*(xinch/4 + xsize/2);
off -= ya.rev ? -off2 : off2;
FontGroupSelect("t", ya.lblfg);
alabel(ya.rev ? "YTR" : "YT", ya.lbl, off, (ywmin+ywmax)/2);
}
}
static TickPtr ticks;
static Uint maxTicks, nTicks;
void TickDef(AxisPtr a, double tick, char *lbl, double scl, Boolean override)
{
TickPtr t;
double delta, tmp;
short n;
if (a->min != DEFAULT && a->max != DEFAULT)
delta = (a->max - a->min)/1e3;
else {
tmp = fabs(tick);
delta = (tmp < 1e-3) ? 1e-3 : tmp/1e3;
}
for (n = 0; n < nTicks; n++) {
t = &ticks[n];
tmp = fabs(tick - t->tick);
if (a->name == (t->a)->name && tmp < delta)
break;
}
if (n == nTicks) {
if (nTicks == maxTicks)
ticks = (TickPtr)azmem(ticks, (size_t *)&maxTicks, 12,
sizeof(*ticks));
t = &ticks[nTicks++];
}
else {
if (!override)
return;
}
t->a = a;
t->tick = tick;
t->lbl = (lbl == 0) ? lbl : StringSave(lbl);
t->scl = (scl == DEFAULT) ? 1.0 : scl;
if (a->rev)
t->scl = -(t->scl);
}
/* Private functions (used only within this module) */
static void AxisInitOne(AxisPtr a)
{
a->min = a->max = a->cr = FDEFAULT;
a->aoff = a->mlt = a->tick = a->tmark = FDEFAULT;
a->tscl = 1;
a->skp = DEFAULT;
a->pfm = a->lbl = a->base = 0;
a->mode = 077777;
a->logflg = a->rev = NO;
a->scl = a->off = 0;
a->acchi = a->acclo = 0.2;
a->numfg = a->lblfg = a->extra = 0;
a->lo = a->hi = 0;
a->this = (a->name == 'x') ? X : Y;
a->other = (a->name == 'x') ? Y : X;
}
static void MinmaxSetup(AxisPtr a)
{
if (a->min != DEFAULT && a->max != DEFAULT && a->min > a->max)
err(YES, "%c axis reversed", a->name);
if (a->min != DEFAULT)
a->acchi = 0;
if (a->max != DEFAULT)
a->acclo = 0;
if (a->logflg)
LogTickSetup(a);
else {
LinearTickLogic(a);
LinearTickSetup(a);
}
}
static void AxisSetup(AxisPtr a, AxisPtr oa)
{
if (a->cr == DEFAULT) {
a->cr = a->rev ? oa->max : oa->min;
if (a->aoff != DEFAULT)
a->cr -= (a->rev ? -1 : 1)*a->aoff*(oa->max-oa->min);
}
a->lo = (*a->other)(a->cr);
a->hi = (*a->other)(oa->max+oa->min-a->cr);
}
static void LinearTickSetup(AxisPtr a)
{
double tick, tend, tscl = a->tscl;
short k, n;
char *tlbl = 0;
switch (a->mode & (TICKMARKS|TICKNUMS)) {
case NOTHING: return;
case TICKMARKS: tlbl = ""; break;
case TICKNUMS: tscl = 0; break;
case TICKMARKS+TICKNUMS: break;
}
n = ceil((a->min - a->tmark)/a->tick - 0.0001);
tick = a->tmark + n*a->tick;
tend = a->max + 0.001*a->tick;
for (k = 0; tick < tend; k++) {
TickDef(a, tick, ((k+n)%a->skp) ? "" : tlbl, tscl, NO);
tick += a->tick;
}
}
static void LogTickSetup(AxisPtr a)
{
double tick, tbeg, tend, tscl, sfract, ftmp, subtick[20];
int k, n, nsubtick;
char *tlbl;
if (a->logflg && a->base == 0)
a->base = "10";
if(a->min == DEFAULT)
a->min = floor((a->name == 'x' ? xmin : ymin) + 0.001);
if(a->max == DEFAULT)
a->max = ceil((a->name == 'x' ? xmax : ymax) - 0.001);
if(a->tmark == DEFAULT)
a->tmark = 0;
if(a->pfm == 0)
a->pfm = "%g";
tlbl = 0;
tscl = a->tscl;
switch (a->mode & (TICKMARKS|TICKNUMS)) {
case NOTHING: return;
case TICKMARKS: tlbl = ""; break;
case TICKNUMS: tscl = 0; break;
case TICKMARKS+TICKNUMS: break;
}
n = ceil((a->min - a->tmark) - 0.0001);
tbeg = a->tmark + n;
tend = a->max;
sfract = ((a->name == 'x') ? (double)(xwmax-xwmin)/p->xfull :
(double)(ywmax-ywmin)/p->yfull)/(tend-tbeg);
if (ticklogic)
err(NO, "tbeg, tend, sfract: %g %g %g\n", tbeg, tend, sfract);
if (a->extra == NULL)
a->extra = (sfract < 0.07) ? "n" : "y";
nsubtick = 0;
if (a->extra[0] == 'y' && (n=atoi(a->base)) > 2) {
if (a->skp == DEFAULT)
a->skp = 1 + 0.05/sfract;
ftmp = 1/log((double)n);
for (k = 2; k < n; k++)
subtick[nsubtick++] = log((double)k)*ftmp;
}
else if (a->skp == DEFAULT)
a->skp = 1 + 0.05/sfract;
for (tick = tbeg; tick <= tend; tick += a->skp) {
TickDef(a, tick, tlbl, tscl, NO);
for (n = 0; n < a->skp; n++) {
if (n > 0 && tick+n-.01 < tend)
TickDef(a, tick+n, "", tscl, NO);
if (a->extra[0] == 'y' && tick+n+0.99 < tend) {
for (k = 0; k < nsubtick; k++)
TickDef(a, tick+n+subtick[k], "", tscl, NO);
}
}
}
}
static void GridSetup(void)
{
char *spec;
if (*gridtype >= '0' && *gridtype <= '9') {
gtype = LongNum(gridtype); /* old-time compatibility */
return;
}
while (*gridtype) {
if (!getstr(&gridtype, &spec))
continue;
if (strcmp(spec,"out") == 0)
gtype = (gtype & ~IN_OUT_MASK) + OUT_TICK;
else if(strcmp(spec,"in") == 0)
gtype = (gtype & ~IN_OUT_MASK) + IN_TICK;
else if(strcmp(spec,"out") == 0)
gtype = (gtype & ~IN_OUT_MASK) + OUT_TICK;
else if(strcmp(spec,"both") == 0)
gtype = (gtype & ~IN_OUT_MASK) + IN_OUT_TICK;
else if(strncmp(spec,"no",2) == 0)
gtype = (gtype & ~IN_OUT_MASK);
else if(strncmp(spec,"sym",3) == 0)
gtype |= SYMMETRIC;
else if(strcmp(spec,"grid") == 0)
gtype |= GRID;
else if(strcmp(spec,"xgrid") == 0)
gtype |= XGRID;
else if(strcmp(spec,"ygrid") == 0)
gtype |= YGRID;
else if(strncmp(spec,"sub",3) == 0)
gtype |= SUB_GRID;
else
err(YES, "Unrecognized tick spec `%s'", spec);
while(*gridtype == ',')
gridtype++;
}
}
static void GridDraw(AxisPtr a, AxisPtr oa)
{
TickPtr t;
Ptype n, itick, min, max;
FontGroupSelect("a", gridfg);
min = (*oa->this)(oa->min);
max = (*oa->this)(oa->max);
for (n = 0; n < nTicks; n++) {
t = &ticks[n];
if ((t->a)->name == a->name &&
(t->lbl == 0 || *t->lbl != 0 || (gtype & SUB_GRID))) {
itick = (*a->this)(t->tick);
if (a->name == 'x')
line(itick, min, itick, max);
else
line(min, itick, max, itick);
}
}
}
static Ptype TickDrawAxis(AxisPtr a)
{
TickPtr t;
double fudge;
Ptype off, toff, ticklen, ticksize;
short n;
Boolean lbl;
fudge = 0.3 * (double)chht/yinch * (3+xfract+yfract);
ticksize = fudge * ((a->name == 'x') ? xinch : yinch)/5.0;
toff = a->lo;
for (n = 0, t = ticks; n < nTicks; n++, t++) {
if ((t->a)->name == a->name) {
lbl = !(t->lbl && t->lbl[0] == 0);
ticklen = (lbl ? (3*ticksize+1)/2 : ticksize) * t->scl;
off = TickDraw(t, ticklen);
if (lbl)
TickLabel(t, off);
if (a->rev ? (toff < off) : (toff > off))
toff = off;
}
}
return (toff);
}
#define XYTICK(A,B) (isx ? line(itick, A, itick, off=B) \
: line(A, itick, off=B, itick))
static int TickDraw(TickPtr t, Ptype ticklen)
{
AxisPtr a;
int isx, itick, off;
a = t->a;
itick = (*a->this)(t->tick);
isx = (a->name == 'x');
if (gtype & SYMMETRIC)
switch (gtype & IN_OUT_MASK) {
case NO_TICK: break;
case IN_TICK: XYTICK(a->hi, a->hi-ticklen); break;
case OUT_TICK: XYTICK(a->hi+ticklen, a->hi); break;
case IN_OUT_TICK: XYTICK(a->hi+ticklen, a->hi-ticklen); break;
}
switch (gtype & IN_OUT_MASK) {
case NO_TICK: off = a->lo; break;
case IN_TICK: XYTICK(a->lo+ticklen, a->lo); break;
case OUT_TICK: XYTICK(a->lo, a->lo-ticklen); break;
case IN_OUT_TICK: XYTICK(a->lo+ticklen, a->lo-ticklen); break;
}
return (off);
}
static void TickLabel(TickPtr t, int off)
{
AxisPtr a;
Boolean rev;
char str[60];
a = t->a;
if (t->lbl == 0) {
double tmp = fabs(t->tick);
if((a->max-a->min)*1e-6 > tmp)
t->tick = 0;
sprintf(str, a->pfm, t->tick);
t->lbl = StringSave(str);
}
rev = (t->scl < 0);
if (a->logflg) {
if (a->name == 'x')
elabel(rev ? "XER" : "XE", a->base, t->lbl, X(t->tick), off);
else
elabel(rev ? "YER" : "YE", a->base, t->lbl, off, Y(t->tick));
}
else {
if (a->name == 'x')
alabel(rev ? "XNR" : "XN", t->lbl, X(t->tick), off);
else
alabel(rev ? "YNR" : "YN", t->lbl, off, Y(t->tick));
}
}