/* file: plot.c Paul Albrecht September 1984
Last revised: 25 March 2009
Generate data plots
Copyright (C) Paul Albrecht 1988
Recent changes (by George Moody, george@mit.edu):
15 March 2001: fixed FILLED mode
15 April 2001: general cleanup
14 November 2002: fixed missing casts in azmem calls
25 March 2009: added HISTOGRAM mode
_______________________________________________________________________________
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 GETPM(DFLT) (*cp ? *cp++ : DFLT)
#define UNGETPM(CHR) { if( *(--cp) != CHR) ASSERT(NO, "Bug in UNGETPM"); }
#define PMBLANK(C) ((C) == ' ' || (C) == ',' || (C) == '/')
/* Prototypes of functions defined in this module */
void PlotDef(char *pspec);
void PlotDraw(PltPtr plt);
void PlotInit(Mode mode);
void PlotNameDef(long n, char *name);
void SmallBox(Ptype x, Ptype y);
Ptype X(double x);
Ptype Y(double y);
static void GetScatInfo(PltPtr plt);
static void GetCols(PltPtr plt, int n);
static void PlotText(Ptype x, Ptype y, double dbl);
static char *FontInfoString(double *dptr);
static void spen(PltPtr plt, double dx, double dy, double yerr);
static Boolean pen(Boolean draw, Ptype x, Ptype y);
static Boolean OutOfRange(Ptype x, Ptype y);
static short lastuse, nextuse, use[20], useall, nextcol;
static char *cp;
void PlotInit(Mode mode)
{
PltPtr plt;
short n;
for (n = 0; n < Plot.nPlts; n++) {
plt = &Plot.plts[n];
if (plt->fgName) FREE(plt->fgName);
if (plt->name) FREE(plt->name);
}
if (Plot.plts != 0) FREE(Plot.plts);
Plot.nPlts = 0;
Plot.suppress = zmem(20, 1);
Plot.defaultPMode = NORMAL;
Plot.exclude = YES;
Plot.xFrom = FDEFAULT;
Plot.xIncr = FDEFAULT;
}
/* Match up plot specification (-p option) with columns */
void PlotDef(char *pspec)
{
PltPtr plt;
short n;
char c, cf, str[100];
nextcol = nextuse = lastuse = 0;
useall = YES;
cp = pspec;
while (*cp || (useall && nextcol < Data.nCols)) {
if (*cp == 0) {
if (!useall || nextcol == Data.nCols)
break;
}
if (Plot.nPlts == Plot.maxPlts)
Plot.plts = (PltPtr)azmem(Plot.plts, (size_t *)&Plot.maxPlts, 2,
sizeof(*Plot.plts));
plt = &Plot.plts[Plot.nPlts++];
plt->c2 = NO_COL;
plt->c3 = NO_COL;
while (YES) {
while (PMBLANK(*cp))
cp++;
if (*cp < '0' || *cp > '9')
break;
n = 0;
while (*cp >= '0' && *cp <= '9')
n = 10*n + ((*cp++ -'0')&0177);
if (n > Data.nCols)
err(YES, "Bad column: %d", n);
use[lastuse++] = n;
useall = NO;
}
while (PMBLANK(*cp))
cp++;
if (*cp == '(' || *cp == '[')
plt->pm = Plot.defaultPMode;
else
plt->pm = GETPM(Plot.defaultPMode);
Plot.defaultPMode = NORMAL;
switch (plt->pm) {
case LABEL_N:
case OUTLINEFILL:
case FILLBETWEEN:
case OUTLINE:
case CDRIVEN: GetCols(plt, 3); break;
case IMPULSE: ymin = ymax = 0; /* Flow through to NORMAL */
case DARKNORMAL:
case FILLED:
case NORMAL: GetCols(plt, 2); break;
case NCOLZERO: GetCols(plt, 1); plt->c1 = plt->c0; plt->c0 = 0; break;
case HISTOGRAM:
case LINES: GetCols(plt, 4); break;
case SYMBOL:
case SCATTER:
case SYMBOL_STD:
case SCATTER_STD: GetScatInfo(plt); break;
default: err(YES, "Bad plot mode spec `%c'", cp[-1]); break;
}
if (nextuse != lastuse)
err(YES, "Too many columns for `%c'", plt->pm);
lastuse = nextuse = 0;
while (PMBLANK(*cp))
cp++;
if (*cp == '[' || *cp == '(') {
n = 0;
cf = *cp++;
do {
str[n++] = c = *cp++;
} while(c && c != ']' && c != ')');
if (c != ']' && c != ')')
err(YES, "Unterminated %c in `%s'", cf, Plot.pModes);
str[n-1] = 0;
plt->fgName = StringSave(str);
}
}
if (*cp)
err(YES, "Not enough columns for `%s'", cp);
}
static void GetScatInfo(PltPtr plt)
{
static struct {
char *name;
short n;
} *s, sym[] = { /* The first 10 entries must not be altered !!! ... */
"0", 0, "1", 1, "2", 2, "3", 3, "4", 4, "5", 5, "6", 6, "7", 7, "8", 8,
"9", 9,
"circle", 0, "utriangle", 1, "diamond", 2, "square", 3, "triangle", 4,
"fcircle", 5, "futriangle", 6, "fdiamond", 7, "fsquare", 8,
"ftriangle", 9
};
short nchrs;
char c, symname[20];
if (plt->pm == SCATTER_STD || plt->pm == SYMBOL_STD) {
GetCols(plt, 3);
c = GETPM(SYMMETRIC_STD);
if (c == SYMMETRIC_STD || c==UP_STD || c==DOWN_STD) {
plt->subpm = c | 040;
c = GETPM('*');
}
else
plt->subpm = SYMMETRIC_STD;
}
else {
GetCols(plt, 2);
plt->subpm = 0;
c = GETPM('.');
}
if (plt->pm == SYMBOL || plt->pm == SYMBOL_STD) {
while (PMBLANK(c))
c = GETPM(0);
for (nchrs = 0; nchrs < sizeof(symname)-1; nchrs++) {
symname[nchrs] = c;
if ((c < 'a' || c > 'z') && (c < '0' || c > '9'))
break;
c = GETPM(0);
}
symname[nchrs] = 0;
if (c != 0)
UNGETPM(c);
for (s = sym; YES; s++) {
if (strcmp(s->name,symname) == 0 ||
strncmp(s->name,symname,nchrs) == 0)
break;
if (s+1 == ENDP(sym))
err(YES, "No symbol type `%s'", symname);
}
plt->pc = *sym[s->n].name; /* ... and this is why !!!!!! */
plt->symbol = YES;
}
else
plt->pc = c;
}
static void GetCols(PltPtr plt, int n)
{
short *col;
col = &plt->c0;
while (n-- > 0) {
if (lastuse > 0) {
if (nextuse < lastuse)
*col++ = use[nextuse++];
else
err(YES, "Too few columns for `%c'", plt->pm);
}
else {
if (nextcol < Data.nCols)
*col++ = nextcol++;
else
err(YES, "Ran out of columns for `%c'", plt->pm);
}
}
}
void PlotNameDef(long n, char *name)
{
while (n >= Plot.maxPlts)
Plot.plts = (PltPtr)azmem(Plot.plts, (size_t *)&Plot.maxPlts, 5,
sizeof(*Plot.plts));
Plot.plts[n].name = StringSave(name);
}
/* Output the plot specified by structure *plt */
void PlotDraw(PltPtr plt)
{
PtrUnion arg0, arg1;
double *c0, *c1, *c2, *c3, gray;
Ptype n, x, y, xFirst, yFirst;
Boolean dflag, pflag;
c0 = &Data.row[plt->c0];
c1 = &Data.row[plt->c1];
c2 = (plt->c2 == NO_COL) ? 0 : &Data.row[plt->c2];
c3 = (plt->c3 == NO_COL) ? 0 : &Data.row[plt->c3];
FontGroupSelect("p", plt->fgName);
dflag = pflag = NO;
DataRead(YES);
xFirst = DEFAULT;
while (DataRead(NO)) {
x = X(*c0);
y = Y(*c1);
if (xFirst == DEFAULT) {
xFirst = x;
yFirst = y;
}
switch (plt->pm) {
case LABEL_N:
if (!OutOfRange(x,y))
PlotText(x, y, *c2);
break;
case CDRIVEN: /* kludgy mode, but flexible */
n = *c2;
if (n == CSTROKE || n == CFILL || n == CBBFILL) {
if (dflag)
PolyDef(x, y, n);
dflag = NO;
}
else if (n >= CTEXT)
n = CTEXT;
else if (n >= CSYMBOL && n < CSYMBOL+10) /* up to 10 symbols */
n = CSYMBOL;
else if (n == CFILLI || n == CFILLI+1)
n = CFILLI;
else if (n == CBBFILLI || n == CBBFILLI+1)
n = CBBFILLI;
else if (dflag && n != CCONT) {
PolyDef(0, 0, COSTROKE);
dflag = NO;
}
switch (n) {
case CCONT: PolyDef(x, y, dflag ? CCONT : CMOVE);
dflag = YES;
break;
case CMOVE: PolyDef(x, y, CMOVE);
dflag = YES;
break;
case CDOT: plt->pc = '.';
spen(plt, x, y, 0.0);
break;
case CBOX: SmallBox(x, y);
break;
case CBBFILLI:
case CFILLI: gray = *c2 - n;
arg0.d = &gray;
special(SETGRAYD, arg0, arg1);
PolyDef(x, y, n);
arg0.d = &oldGrayLevel;
special(SETGRAY, arg0, arg1);
dflag = NO;
break;
case CSYMBOL: plt->pc = '0'+ (short)(*c2-n);
plt->symbol = YES;
scatterplot(plt, x, y, y, y);
dflag = plt->symbol = NO;
break;
case CTEXT: PlotText(x, y, *c2-n);
dflag = NO;
break;
case CHANGEFNT:
old_font = FontInfoString(c0);
if (*c1 > 0)
old_ps = *c1;
arg0.c = old_font;
arg1.d = &old_ps;
special(SETFONT, arg0, arg1);
break;
case CHANGEPS:
old_ps = *c0;
arg0.c = old_font;
arg1.d = &old_ps;
special(SETFONT, arg0, arg1);
break;
case CHANGELW:
old_lw = *c0;
arg0.d = &old_lw;
special(SETLINEWIDTH, arg0, arg1);
break;
case CHANGEGRAY:
oldGrayLevel = *c0;
arg0.d = &oldGrayLevel;
special(SETGRAY, arg0, arg1);
break;
case CHANGECOLOR:
arg0.c = FontInfoString(c0);
special(SETCOLOR, arg0, arg1);
break;
case CHANGELM:
old_lm = FontInfoString(c0);
arg0.c = old_lm;
special(SETLINEMODE, arg0, arg1);
break;
}
break;
case DARKNORMAL:
case OUTLINEFILL:
if (dflag)
PolyDef(x, y, CBBCONT);
else
PolyDef(x, y, CMOVE);
dflag = YES;
break;
case FILLED:
case FILLBETWEEN:
case OUTLINE:
if (dflag)
PolyDef(x, y, CCONT);
else
PolyDef(x, y, CMOVE);
dflag = YES;
break;
case NCOLZERO:
case NORMAL:
dflag = pen(dflag, x, y);
pflag |= dflag;
break;
case IMPULSE:
pen(NO, x, Y(0.0));
pen(YES, x, y);
SmallBox(x, y);
break;
case SYMBOL:
case SCATTER:
spen(plt, *c0, *c1, 0.0);
break;
case SYMBOL_STD:
case SCATTER_STD:
spen(plt, *c0, *c1, *c2);
break;
case LINES:
pen(NO, x, y);
pen(YES, X(*c2), Y(*c3));
break;
case HISTOGRAM:
PolyDef(x, y, CMOVE);
PolyDef(x, Y(*c3), CCONT);
PolyDef(X(*c2), Y(*c3), CCONT);
PolyDef(X(*c2), y, CCONT);
PolyDef(x, y, CFILL);
break;
}
}
switch (plt->pm) {
case CDRIVEN:
if(dflag)
PolyDef(x, y, COSTROKE);
break;
case DARKNORMAL:
y = Y(ya.min);
PolyDef(x, y, CBBCONT);
PolyDef(xFirst, y, CBBFILL);
break;
case FILLBETWEEN:
ReverseDataRead(YES);
while (ReverseDataRead(NO))
PolyDef(X(*c0), Y(*c2), CBBCONT);
PolyDef(xFirst, yFirst, CFILL);
break;
case FILLED:
PolyDef(xFirst, yFirst, CFILL);
break;
case OUTLINEFILL:
ReverseDataRead(YES);
while (ReverseDataRead(NO))
PolyDef(X(*c0), Y(*c2), CBBCONT);
PolyDef(xFirst, yFirst, CBBFILL);
break;
case OUTLINE:
ReverseDataRead(YES);
while (ReverseDataRead(NO))
PolyDef(X(*c0), Y(*c2), CCONT);
PolyDef(xFirst, yFirst, CSTROKE);
break;
}
if (plt->name && pflag)
label(plt->name);
else
pen(NO, xwmin, ywmin);
}
/* Output a string provided by the -tf or -ts option */
static void PlotText(Ptype x, Ptype y, double dbl)
{
short n;
char lbl[30];
if (pstr.n > 0) {
n = dbl;
if (n >= 0 && n < pstr.n)
plabel(pstr.list[n], x, y, pstr.just, 0.0);
else
err(NO, "Plot string %g undefined", dbl);
}
else {
sprintf(lbl, "%g", dbl);
plabel(lbl, x, y, "CC", 0.0);
}
}
/* Match the index *dptr with a string provided by the -fs option */
static char *FontInfoString(double *dptr)
{
short n;
n = *dptr;
if (fgstr.list == 0 || n < 0 || n >= fgstr.n)
err(YES, "No string for font index %lg", *dptr);
return (fgstr.list[n]);
}
void SmallBox(Ptype x, Ptype y)
{
static Ptype xd, yd;
if (xd == 0) {
xd = (p->xfull+256)/512;
yd = (p->yfull+195)/390;
}
move(x-xd, y-yd);
cont(x+xd, y-yd);
cont(x+xd, y+yd);
cont(x-xd, y+yd);
cont(x-xd, y-yd);
}
static void spen(PltPtr plt, double dx, double dy, double yerr)
{
Ptype x, y, yneg, ypos;
x = X(dx);
y = Y(dy);
if (OutOfRange(x,y)) {
Plot.excluded++;
return;
}
switch (plt->pm ) {
case SYMBOL:
case SCATTER:
if (plt->pc == ' ')
SmallBox(x, y);
else
scatterplot(plt, x, y, y, y);
break;
case SYMBOL_STD:
case SCATTER_STD:
if (plt->pc == ' ') {
SmallBox(x, y);
break;
}
yneg = Y(dy-yerr);
ypos = Y(dy+yerr);
switch (plt->subpm) {
case SYMMETRIC_STD: break;
case UP_STD: yneg = y; break;
case DOWN_STD: ypos = y; break;
}
scatterplot(plt, x, y, yneg, ypos);
break;
}
}
static Boolean pen(Boolean draw, Ptype x, Ptype y)
{
static Boolean oldOff = YES, off;
off = OutOfRange(x, y);
if (off) {
Plot.excluded++;
return (NO);
}
if (!draw || oldOff)
move(x, y);
else
cont(x, y);
oldOff = off;
return (YES);
}
static Boolean OutOfRange(Ptype x, Ptype y)
{
if (Plot.exclude)
return ((x < xwmin) || (x > xwmax) || (y < ywmin) || (y > ywmax));
else
return((x < 0) || (x > p->xfull) || (y < 0) || (y > p->yfull));
}
Ptype X(double xpt)
{
Ptype x = xpt * xa.scl + xa.off;
if (x < 0)
x = 0;
else if (x > p->xfull)
x = p->xfull;
return (x);
}
Ptype Y(double ypt)
{
Ptype y = ypt * ya.scl + ya.off;
if (y < 0)
y = 0;
else if (y > p->yfull)
y = p->yfull;
return (y);
}