/* file: dbnotes.c G. Moody 25 August 1988
Last revised: 24 May 1997
Create database notes file (HTML format)
Copyright (C) Massachusetts Institute of Technology 1997. All rights reserved.
*/
#include <stdio.h>
#include <ecg/db.h>
#include <ecg/ecgmap.h>
/* Rhythm types. These may be rearranged arbitrarily; the order determines
the order in which rhythms are printed in the rhythm table. Add a call to
`setrtab' and adjust N_RTYPES whenever another rhythm is added. */
#define R_UNDEF 0
#define NSR 1
#define SBR 2
#define BII 3
#define B22 4
#define B3 5
#define SAB 6
#define PREX 7
#define AB 8
#define EAR 9
#define SVTA 10
#define AFL 11
#define AFIB 12
#define PR 13
#define NOD 14
#define VBG 15
#define VTG 16
#define IVR 17
#define VT 18
#define VFL 19
#define N_RTYPES 20 /* number of rhythm types, including R_UNDEF */
/* ST and T change types. */
#define STP 0 /* increase in ST level */
#define STN 1 /* decrease in ST level */
#define TP 2 /* increase in T amplitude */
#define TXP 3 /* extreme increase in T amplitude */
#define TN 4 /* decrease in T amplitude */
#define TXN 5 /* extreme decrease in T amplitude */
#define TBP 6 /* biphasic T-wave */
#define N_STYPES 7 /* number of ST and T change types */
#define PLUS 1 /* positive change */
#define MINUS 2 /* negative change */
#define XPLUS 3 /* extreme positive change */
#define XMINUS 4 /* extreme negative change */
#define BIPHASIC 5 /* change to biphasic form */
#define STCH0 1 /* beginning of ST change episode */
#define STCH1 2 /* extremum of ST change */
#define STCH2 3 /* end of ST change episode */
#define TCH0 4 /* beginning of T change episode */
#define TCH1 5 /* extremum of T change */
#define TCH2 6 /* end of T change episode */
/* Noise type bit masks. */
#define C0 0x00 /* signal 0 clean */
#define C1 0x00 /* signal 1 clean */
#define C2 0x00 /* signal 2 clean */
#define C3 0x00 /* signal 3 clean */
#define N0 0x01 /* signal 0 noisy */
#define N1 0x02 /* signal 1 noisy */
#define N2 0x04 /* signal 2 noisy */
#define N3 0x08 /* signal 3 noisy */
#define U0 0x11 /* signal 0 unreadable */
#define U1 0x22 /* signal 1 unreadable */
#define U2 0x44 /* signal 2 unreadable */
#define U3 0x88 /* signal 3 unreadable */
#define UNREADABLE 0xff /* all signals unreadable */
#define N_NTYPES 256 /* number of noise types */
#define N_RLEN 20 /* number of distinct run lengths */
/* Values for info_type. */
#define NO_INFO 0
#define MITDB 1
#define EDB 2
#define VALEDB 3
struct btabstruct {
long lcount; /* number of beats of this type in learning period */
long tcount; /* number of beats of this type in test period */
} btab[ACMAX+1];
struct rltabstruct {
long len; /* number of beats in run */
long nruns; /* number of runs of `len' beats */
} artab[N_RLEN], vrtab[N_RLEN];
struct rtabstruct {
long episodes; /* number of episodes of this rhythm */
long duration; /* duration of this rhythm (in sample intervals) */
char *rstring; /* rhythm string as it appears in annotation file */
char *rslong; /* rhythm name as it is printed by this program */
int min3r, max3r; /* minimum/maximum length of 3 R-R intervals */
} rtab[N_RTYPES];
struct sttabstruct {
long episodes; /* number of episodes of ST or T change of this type */
long duration; /* duration of episodes (in sample intervals) */
char *ststring; /* description of change as printed by this program */
int extremum; /* extreme value of change */
} sttab[N_STYPES][MAXSIG];
struct ntabstruct {
long episodes; /* number of episodes of this noise type */
long duration; /* duration of this noise type (in sample intervals) */
char *nstring; /* noise type as it is printed by this program */
} ntab[N_NTYPES];
long lsum, tsum; /* numbers of beats of all types in the learning and
test periods (tallied by `bstats') */
long ttest; /* time of the end of the test period */
main(argc, argv)
int argc;
char *argv[];
{
double t3min;
int a=0, age, c, i, info_type, magnitude, maxrate, minrate, noise = 0,
nsig, rhythm = R_UNDEF, rlen = -1, rr3, sign, st_calibrated = 0,
st_data = 0, t_data = 0, type, v=0;
static long n0, r0, tq0, tq1, tq2, tq3, s0[N_STYPES][MAXSIG];
struct siginfo si[MAXSIG];
struct anninfo ai;
struct ann annot;
static char buf[256], *infop, *p, *record, sex[10], umask;
/* Check command-line arguments. */
if (argc < 3) {
fprintf(stderr, "usage: %s annotator record\n", argv[0]);
exit(1);
}
/* Open the database files. */
ai.name = argv[1]; ai.stat = READ; record = argv[2];
if (annopen(record, &ai, 1) < 0 ||
(nsig = isigopen(record, si, -MAXSIG)) < 0)
exit(2);
/* Initialize variables. */
t3min = strtim("3:0");
ttest = strtim("5:0");
setrtab(R_UNDEF, NULL, "Unspecified rhythm");
setrtab(NSR, "N", "Normal sinus rhythm");
setrtab(SBR, "SBR", "Sinus bradycardia");
setrtab(BII, "BII", "2\\(de heart block");
setrtab(B22, "B22", "2\\(de heart block (Mobitz type II)");
setrtab(B3, "B3", "3\\(de heart block");
setrtab(SAB, "SAB", "Sino-atrial block");
setrtab(PREX, "PREX", "Pre-excitation (WPW)");
setrtab(AB, "AB", "Atrial bigeminy");
setrtab(EAR, "EAR", "Ectopic atrial rhythm");
setrtab(SVTA, "SVTA", "SVTA");
setrtab(AFL, "AFL", "Atrial flutter");
setrtab(AFIB, "AFIB", "Atrial fibrillation");
setrtab(PR, "P", "Paced rhythm");
setrtab(NOD, "NOD", "Nodal (junctional) rhythm");
setrtab(VBG, "B", "Ventricular bigeminy");
setrtab(VTG, "T", "Ventricular trigeminy");
setrtab(IVR, "IVR", "Idioventricular rhythm");
setrtab(VT, "VT", "Ventricular tachycardia");
setrtab(VFL, "VFL", "Ventricular flutter");
for (c = 0; c < nsig; c++) {
setstab(STP, c, "Positive ST dev.");
setstab(STN, c, "Negative ST dev.");
setstab(TP, c, "Positive T dev.");
setstab(TXP, c, "T dev. \\(>= 400 \\(*mV");
setstab(TN, c, "Negative T dev.");
setstab(TXN, c, "T dev. \\(<= \\(mi400 \\(*mV");
setstab(TBP, c, "Biphasic T");
}
switch (nsig) {
case 1:
setntab(C0, "Clean");
setntab(N0, "Noisy");
setntab(U0, "Unreadable");
setntab(UNREADABLE, "Unreadable");
umask = U0;
break; /* so far, so good ... */
case 2:
setntab(C0|C1, "Both clean");
setntab(C0|N1, "Lower noisy");
setntab(C0|U1, "Lower unreadable");
setntab(N0|C1, "Upper noisy");
setntab(N0|N1, "Both noisy");
setntab(N0|U1, "Upper noisy, lower unreadable");
setntab(U0|C1, "Upper unreadable");
setntab(U0|N1, "Upper unreadable, lower noisy");
setntab(U0|U1, "Both unreadable");
setntab(UNREADABLE, "Unreadable");
umask = U0|U1;
break; /* yikes! */
case 3:
setntab(C0|C1|C2, "All clean");
setntab(C0|C1|N2, "Lower noisy");
setntab(C0|C1|U2, "Lower unreadable");
setntab(C0|N1|C2, "Middle noisy");
setntab(C0|N1|N2, "Middle and lower noisy");
setntab(C0|N1|U2, "Middle noisy, lower unreadable");
setntab(C0|U1|C2, "Middle unreadable");
setntab(C0|U1|N2, "Middle unreadable, lower noisy");
setntab(C0|U1|U2, "Middle and lower unreadable");
setntab(N0|C1|C2, "Upper noisy");
setntab(N0|C1|N2, "Upper and lower noisy");
setntab(N0|C1|U2, "Upper noisy, lower unreadable");
setntab(N0|N1|C2, "Upper and middle noisy");
setntab(N0|N1|N2, "All noisy");
setntab(N0|N1|U2, "Lower unreadable, others noisy");
setntab(N0|U1|C2, "Upper noisy, middle unreadable");
setntab(N0|U1|N2, "Middle unreadable, others noisy");
setntab(N0|U1|U2, "Upper noisy, others unreadable");
setntab(U0|C1|C2, "Upper unreadable");
setntab(U0|C1|N2, "Upper unreadable, lower noisy");
setntab(U0|C1|U2, "Upper and lower unreadable");
setntab(U0|N1|C2, "Upper unreadable, middle noisy");
setntab(U0|N1|N2, "Upper unreadable, others noisy");
setntab(U0|N1|U2, "Middle noisy, others unreadable");
setntab(U0|U1|C2, "Upper and middle unreadable");
setntab(U0|U1|N2, "Lower noisy, others unreadable");
setntab(U0|U1|U2, "All unreadable");
setntab(UNREADABLE, "Unreadable");
umask = U0|U1|U2;
break; /* arggggh! */
/* case 4: nonononononononononono!!!!!!! */
default:
umask = UNREADABLE;
break;
}
/* Read the annotation file. */
while (getann(0, &annot) >= 0) {
/* Count the annotation in the test or learning period as appropriate. */
if (annot.time >= ttest) btab[annot.anntyp].tcount++;
else btab[annot.anntyp].lcount++;
if (isqrs(annot.anntyp)) {
/* Update the ectopic activity tables if appropriate. */
switch (map2(annot.anntyp)) {
case NORMAL: if (a > 0) { aupdate(a); a = 0; }
if (v > 0) { vupdate(v); v = 0; }
break;
case SVPB: if (v > 0) { vupdate(v); v = 0; }
a++;
break;
case PVC:
case FUSION: if (a > 0) { aupdate(a); a = 0; }
v++;
break;
}
/* Keep track of the times of the last 4 beats. */
tq0 = tq1; tq1 = tq2; tq2 = tq3; tq3 = annot.time;
/* Update the count of consecutive beats in the current rhythm. */
rlen++;
/* Check various conditions which might make a heart rate
measurement invalid. */
switch (rhythm) {
case NSR:
case SBR:
case BII:
case B22:
case B3:
case SAB:
case PREX:
if (map2(annot.anntyp) != NORMAL) rlen = -1; break;
case AB:
case NOD:
if (map1(annot.anntyp) != NORMAL) rlen = -1; break;
case EAR:
case SVTA:
if (map2(annot.anntyp) != SVPB) rlen = -1; break;
case PR:
if (annot.anntyp != PACE) rlen = -1; break;
case IVR:
case VT:
if (map1(annot.anntyp) == NORMAL) rlen = -1; break;
case VFL:
if (annot.anntyp != FLWAV) rlen = -1; break;
default:
break;
}
/* If a valid heart rate can be measured, update the records of
maximum and minimum rate for the current rhythm. Note that
these can be determined from the minimum and maximum R-R
intervals; what is actually used here is the sum of three
consecutive intervals. */
if (rlen >= 3) {
rr3 = tq3 - tq0;
if (rr3 > rtab[rhythm].max3r) rtab[rhythm].max3r = rr3;
if (rr3 < rtab[rhythm].min3r) rtab[rhythm].min3r = rr3;
}
}
else if (annot.anntyp == RHYTHM) {
/* Don't count the interval from the beginning of the record to
the first rhythm label as `unspecified rhythm' unless the first
beat label occurs before the first rhythm label. */
if (tq3 > 0L) {
rtab[rhythm].episodes++;
rtab[rhythm].duration += annot.time - r0;
r0 = annot.time;
}
/* Identify the new rhythm. */
for (i = 1, rhythm = R_UNDEF; i < N_RTYPES; i++)
if (strcmp(annot.aux+2, rtab[i].rstring) == 0) {
rhythm = i;
break;
}
if (rhythm == SVTA || rhythm == VT) rlen = 0;
else rlen = -1;
}
else if (annot.anntyp == STCH || annot.anntyp == TCH) {
/* Identify the nature of the ST or T change from the aux field.
The syntax of the aux field is one of:
"(" <type> [<signal designation>] <sign>
"A" <type> [<signal designation>] <sign> [<magnitude>]
<type> [<signal designation>] <sign> ")"
where <type> is "ST" or "T", <signal designation> is 1 or 2
decimal digits, <sign> is "+", "++", "-", "--", or "BP", and
<magnitude> is 2-4 decimal digits. ("++" and "--" appear only
in T-wave change annotations; they designate extreme (>= 0.4 mV
changes in T-wave amplitude.) The signal designation is
the signal number (e.g., signal 0 is designated by "0",
etc.); in records which contain only one signal (such as those
in the VALE DB), the signal designation is omitted. The
magnitude is given in microvolts, and may also be omitted (as
in the VALE DB).
*/
if (annot.aux == NULL)
fprintf(stderr,
"warning: %s annotation without text field at %s\n",
ecgstr(annot.anntyp), timstr(annot.time));
else {
p = annot.aux+1;
switch (*p) {
case '(':
if (annot.anntyp == STCH) {
type = STCH0;
p += 3; /* skip `(ST' */
}
else {
type = TCH0;
p += 2; /* skip `(T' */
}
break;
case 'A':
if (annot.anntyp == STCH) {
type = STCH1;
p += 3; /* skip `(ST' */
}
else {
type = TCH1;
p += 2; /* skip `(T' */
}
break;
case 'S':
type = STCH2;
p += 2; /* skip `ST' */
break;
case 'T':
type = TCH2;
p++; /* skip `T' */
break;
default:
fprintf(stderr,
"warning: %s annotation with text field %s at %s\n",
ecgstr(annot.anntyp), annot.aux, timstr(annot.time));
type = 0;
break;
}
if (nsig > 1) {
if ((c = atoi(p)) > 9) {
p++;
}
p++;
}
else c = 0;
switch (*p++) {
case '+':
if (*p == '+') {
sign = XPLUS;
p++;
}
else
sign = PLUS;
break;
case '-':
if (*p == '-') {
sign = XMINUS;
p++;
}
else
sign = MINUS;
break;
case 'B':
if (*p == 'P') {
sign = BIPHASIC;
p++;
}
break;
default:
fprintf(stderr,
"warning: %s annotation with text field %s at %s\n",
ecgstr(annot.anntyp), annot.aux, timstr(annot.time));
sign = 0;
break;
}
if (*p && *p != ')') {
if ((magnitude = atoi(p)) > 0)
st_calibrated = 1;
}
else magnitude = 0;
if (0 <= c && c < MAXSIG) switch (type) {
case STCH0: /* beginning of ST change episode */
if (sign == PLUS) {
st_data = 1;
s0[STP][c] = annot.time;
}
else if (sign == MINUS) {
st_data = 1;
s0[STN][c] = annot.time;
}
break;
case STCH1: /* extremum of ST change */
if (sign == PLUS && magnitude > sttab[STP][c].extremum)
sttab[STP][c].extremum = magnitude;
else if (sign == MINUS &&
magnitude > sttab[STN][c].extremum)
sttab[STN][c].extremum = magnitude;
break;
case STCH2: /* end of ST change episode */
if (sign == PLUS) {
sttab[STP][c].episodes++;
sttab[STP][c].duration += annot.time - s0[STP][c];
s0[STP][c] = 0L;
}
else if (sign == MINUS) {
sttab[STN][c].episodes++;
sttab[STN][c].duration += annot.time - s0[STN][c];
s0[STN][c] = 0L;
}
break;
case TCH0: /* beginning of T change episode */
if (sign == PLUS) {
t_data = 1;
s0[TP][c] = annot.time;
}
else if (sign == MINUS) {
t_data = 1;
s0[TN][c] = annot.time;
}
else if (sign == XPLUS) {
t_data = 1;
s0[TXP][c] = annot.time;
}
else if (sign == XMINUS) {
t_data = 1;
s0[TXN][c] = annot.time;
}
else if (sign == BIPHASIC) {
t_data = 1;
s0[TBP][c] = annot.time;
}
break;
case TCH1: /* extremum of T change */
if ((sign == PLUS || sign == XPLUS) &&
magnitude > sttab[TP][c].extremum)
sttab[TP][c].extremum = magnitude;
else if ((sign == MINUS || sign == XMINUS) &&
magnitude > sttab[TN][c].extremum)
sttab[TN][c].extremum = magnitude;
break;
case TCH2: /* end of T change episode */
if (sign == PLUS) {
sttab[TP][c].episodes++;
sttab[TP][c].duration += annot.time - s0[TP][c];
s0[TP][c] = 0L;
}
else if (sign == MINUS) {
sttab[TN][c].episodes++;
sttab[TN][c].duration += annot.time - s0[TN][c];
s0[TN][c] = 0L;
}
else if (sign == XPLUS) {
sttab[TXP][c].episodes++;
sttab[TXP][c].duration += annot.time - s0[TXP][c];
s0[TXP][c] = 0L;
}
else if (sign == XMINUS) {
sttab[TXN][c].episodes++;
sttab[TXN][c].duration += annot.time - s0[TXN][c];
s0[TXN][c] = 0L;
}
else if (sign == BIPHASIC) {
sttab[TBP][c].episodes++;
sttab[TBP][c].duration += annot.time - s0[TBP][c];
s0[TBP][c] = 0L;
}
break;
default:
break;
}
}
}
else if (annot.anntyp == NOISE) {
/* Don't count the interval from the beginning of the record to
the first signal quality label as `clean' unless the first beat
label occurs before the first signal quality label. */
if (tq3 > 0L) {
ntab[noise].episodes++;
ntab[noise].duration += annot.time - n0;
n0 = annot.time;
}
noise = annot.subtyp & 0xff;
/* Unreadable segments invalidate rate measurements. */
if ((noise & umask) == umask) rlen = -1;
}
}
/* At the end of the annotation file, count any run in progress and adjust
the counters for the current rhythm and noise type, and ST and T states.
*/
if (a) aupdate(a);
if (v) aupdate(v);
if (strtim("e") > annot.time) annot.time = strtim("e");
rtab[rhythm].episodes++;
rtab[rhythm].duration += annot.time - r0;
for (c = 0; c < nsig; c++) {
for (i = 0; i < N_STYPES; i++)
if (s0[i][c] > 0L) {
sttab[i][c].episodes++;
sttab[i][c].duration += annot.time - s0[i][c];
}
if (sttab[TXP][c].episodes > 0)
sttab[TXP][c].extremum = sttab[TP][c].extremum;
if (sttab[TXN][c].episodes > 0)
sttab[TXN][c].extremum = sttab[TN][c].extremum;
}
ntab[noise].episodes++;
ntab[noise].duration += annot.time - n0;
/* Read the first line of info, if any. */
infop = getinfo(record);
if (infop == NULL)
info_type = NO_INFO;
else {
while (*infop == ' ' || *infop == '\t')
infop++;
if (*infop == 'A') { /* `Age: ...' as in European ST-T DB */
sscanf(infop, "Age: %d Sex: %s", &age, sex);
info_type = EDB;
}
else if (*infop == 'R') { /* `Reference: ...' as in VALE DB */
age = -1; sex[0] = '?';
info_type = VALEDB;
}
else { /* fixed format as in MIT DB */
sscanf(infop, "%d%s", &age, sex);
info_type = MITDB;
}
}
printf("<h2>Record %s (", record);
for (i = 0; i < nsig; i++) {
if (i > 0) fputs(", ", stdout);
fputs(si[i].desc, stdout);
}
fputs("; ", stdout);
switch (sex[0]) {
case 'f':
case 'F': fputs("female, age ", stdout); break;
case 'm':
case 'M': fputs("male, age ", stdout); break;
default: fputs("age ", stdout); break;
}
if (age > 0) printf("%d)</h2>\n", age);
else fputs("not recorded)</h2>\n", stdout);
printf("<p>\n");
switch (info_type) {
case MITDB:
/* Print the medications section (the second line of info). */
if (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf("<i>Medications:</i> %s<br>\n", infop);
}
break;
default:
break;
}
/* Print the beat table. */
printf("<p><table>\n");
/* printf(".TS\nexpand;\nlw(1i) c c c\nl r r r.\n"); */
printf("<tr><th>Beats</th><th>Before 5:00</th><th>After 5:00</th>"
"<th>Total</th></tr>\n");
/* printf("\\fIBeats\tBefore 5:00\tAfter 5:00\tTotal\\fR\n"); */
bstats(NORMAL, "Normal");
bstats(LBBB, "Left BBB");
bstats(RBBB, "Right BBB");
bstats(APC, "APC");
bstats(ABERR, "Aberrated APC");
bstats(NPC, "Junctional premature");
bstats(SVPB, "SVPC");
bstats(PVC, "PVC");
bstats(RONT, "R-on-T PVC");
bstats(FUSION, "Fusion PVC");
bstats(FLWAV, "Ventricular flutter wave");
bstats(AESC, "Atrial escape");
bstats(NESC, "Junctional escape");
bstats(SVESC, "Supraventricular escape");
bstats(VESC, "Ventricular escape");
bstats(PACE, "Paced");
bstats(PFUS, "Pacemaker fusion");
bstats(NAPC, "Blocked APC");
bstats(UNKNOWN, "Unclassifiable");
printf("<tr align=right><td>Total</td><td>%ld</td><td>%ld</td>"
"<td>%ld</td></tr>\n", lsum, tsum, lsum+tsum);
/* printf("\\fITotal\t%ld\t%ld\t%ld\\fR\n", lsum, tsum, lsum+tsum); */
printf("</table>\n\n");
/* printf(".TE\n.KE\n"); */
/* Print the supraventricular ectopy table, if necessary. */
if (artab[0].len > 1 || artab[0].nruns > 1 || artab[1].len > 0) {
int i, j, k, l;
/* printf(".KS\n.TS\nlw(1.125i) l.\n"); */
printf("<p><i>Supraventricular ectopy</i><br>\n<ul>");
/* printf("\\fISupraventricular ectopy:\\fR"); */
for (i = 0; i < N_RLEN; i++) {
for (j = 0, l = 9999; j < N_RLEN; j++)
if (0 < artab[j].len && artab[j].len < l) l = artab[k = j].len;
if (l == 9999) break;
switch (l) {
case 1:
printf("<li> %d isolated beat%s\n",
artab[k].nruns, (artab[k].nruns > 1) ? "s" : "");
break;
case 2:
printf("<li> %d couplet%s\n",
artab[k].nruns, (artab[k].nruns > 1) ? "s" : "");
break;
default:
printf("<li> %d run%s of %d beats\n",
artab[k].nruns, (artab[k].nruns > 1) ? "s" : "",
artab[k].len);
break;
}
artab[k].len = 0;
}
printf("</ul>\n");
/* printf(".TE\n.KE\n"); */
}
/* Print the ventricular ectopy table, if necessary. */
if (vrtab[0].len > 1 || vrtab[0].nruns > 1 || vrtab[1].len > 0) {
int i, j, k, l;
/* printf(".KS\n.TS\nlw(1.125i) l.\n"); */
printf("<p><i>Ventricular ectopy</i><br>\n<ul>");
/* printf("\\fIVentricular ectopy:\\fR"); */
for (i = 0; i < N_RLEN; i++) {
for (j = 0, l = 9999; j < N_RLEN; j++)
if (0 < vrtab[j].len && vrtab[j].len < l) l = vrtab[k = j].len;
if (l == 9999) break;
switch (l) {
case 1:
printf("<li> %d isolated beat%s\n",
vrtab[k].nruns, (vrtab[k].nruns > 1) ? "s" : "");
break;
case 2:
printf("<li> %d couplet%s\n",
vrtab[k].nruns, (vrtab[k].nruns > 1) ? "s" : "");
break;
default:
printf("<li> %d run%s of %d beats\n",
vrtab[k].nruns, (vrtab[k].nruns > 1) ? "s" : "",
vrtab[k].len);
break;
}
vrtab[k].len = 0;
}
printf("</ul>\n");
/* printf(".TE\n.KE\n"); */
}
/* Print the rhythm table. */
printf("<p><table>\n");
/* printf(".KS\n.TS\nexpand;\nlw c rw(0.4i) rw(0.4i)\nl c n r.\n"); */
printf("<tr><th>Rhythm</th><th>Rate</th><th>Episodes</th>"
"<th>Duration</th></tr>\n");
/* printf("\\fIRhythm\tRate\tEpisodes\tDuration\\fR\n"); */
for (i = 0; i < N_RTYPES; i++)
if (rtab[i].episodes != 0L) {
printf("<tr><td>%s</td><td align=center>", rtab[i].rslong);
if (rtab[i].max3r > 0)
printf("%d", minrate = (int)(t3min/rtab[i].max3r + 0.5));
else
minrate = 0;
if (rtab[i].min3r != 0xffff) {
maxrate = (int)(t3min/rtab[i].min3r + 0.5);
if (maxrate > minrate) printf("-%d", maxrate);
}
else if (minrate == 0)
printf("-");
printf("</td><td align=right>%ld</td><td align=right>%s</td>"
"</tr>\n", rtab[i].episodes, timstr(rtab[i].duration));
}
printf("</table>\n\n");
/* printf(".TE\n.KE\n"); */
/* Print the ST and T-change table, if available. */
if (st_data || t_data) {
printf(".KS\n.TS\nexpand;\nl");
if (st_calibrated) printf(" r");
printf(" rw(0.4i) rw(0.4i)\nl");
if (st_calibrated) printf(" n");
printf(" n r.\n\\fIST\\-T state");
if (st_calibrated) printf("\tExtremum");
printf("\tEpisodes\tDuration\\fR\n");
for (c = 0; c < nsig; c++) {
int header_printed = 0;
for (i = 0; i < N_STYPES; i++) {
if (sttab[i][c].episodes != 0L) {
if (header_printed == 0) {
switch (nsig) {
case 1:
break;
case 2:
if (c == 0) printf("\\fI(upper signal)\\fR\n");
else printf("\\fI(lower signal)\\fR\n");
break;
case 3:
if (c == 0) printf("\\fI(upper signal)\\fR\n");
else if (c == 1)
printf("\\fI(middle signal)\\fR\n");
else printf("\\fI(lower signal)\\fR\n");
break;
default:
printf("(signal %d)\n", c);
break;
}
header_printed = 1;
}
printf("%s\t", sttab[i][c].ststring);
if (st_calibrated) {
if (sttab[i][c].extremum > 0) {
switch (i) {
case STP:
case TP:
case TXP: printf("\\(pl"); break;
case STN:
case TN:
case TXN: printf("\\(mi"); break;
}
printf("%d\t", sttab[i][c].extremum);
}
else
printf("\\-\t");
}
printf("%ld\t%s\n", sttab[i][c].episodes,
timstr(sttab[i][c].duration));
}
}
}
printf(".TE\n.KE\n");
}
/* Print the signal quality table. */
printf("<p><table>\n");
/* printf(".KS\n.TS\nexpand;\nl rw(0.4i) rw(0.4i)\nl n r.\n"); */
printf("<tr><th>Signal quality</th><th>Episodes</th>"
"<th>Duration</th></tr>\n");
/* printf("\\fISignal quality\tEpisodes\tDuration\\fR\n"); */
for (i = 0; i < N_NTYPES; i++)
if (ntab[i].episodes != 0L) {
if (ntab[i].nstring == NULL) {
static char ns[40];
sprintf(ns, "Signal quality code %d", i);
ntab[i].nstring = ns;
}
printf("<tr><td>%s</td><td align=right>%ld</td>"
"<td align=right>%s</td></tr>\n",
ntab[i].nstring, ntab[i].episodes,
timstr(ntab[i].duration));
}
printf ("</table>\n\n");
/* printf(".TE\n"); */ /* (the "keep" ends after the "notes" section) */
/* Print a "notes" section if there is any additional info available. */
switch (info_type) {
case EDB:
if (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
if ('a' <= *infop && *infop <= 'z') *infop += 'A' - 'a';
printf("<p><dl><dt>Notes:</dt>\n<dd>%s", infop);
while (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf("<br>\n%s", infop);
}
printf("</dd></dl>\n");
}
/* else
printf(".LP\n"); */
break;
case MITDB:
if (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf("<p><dl><dt>Notes:</dt>\n<dd>%s\n", infop);
while (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf("%s\n", infop);
}
printf("</dd></dl>\n");
}
/* else
printf(".LP\n"); */
break;
case VALEDB:
if (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
if (strncmp(infop, "Reference:", 10) == 0)
infop = getinfo(NULL);
}
if (infop) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf(".IP \\fINotes:\\fR .375i\n%s\n", infop);
while (infop = getinfo(NULL)) {
while (*infop == ' ' || *infop == '\t')
infop++;
printf(".br\n%s\n", infop);
}
}
else
printf(".LP\n");
break;
default:
printf(".LP\n");
break;
}
/* printf(".KE\n"); */
/* Close the database files and quit. */
dbquit();
exit(0);
}
setrtab(i, rst, rsl)
int i;
char *rst, *rsl;
{
if (0 <= i && i < N_RTYPES) {
rtab[i].episodes = 0L;
rtab[i].duration = strtim("0.5");
rtab[i].rstring = rst;
rtab[i].rslong = rsl;
rtab[i].min3r = 0xffff;
rtab[i].max3r = 0;
}
}
setstab(i, signal, sst)
int i, signal;
char *sst;
{
if (0 <= i && i < N_STYPES && 0 <= signal && signal < MAXSIG) {
sttab[i][signal].episodes = 0L;
sttab[i][signal].duration = strtim("0.5");
sttab[i][signal].ststring = sst;
sttab[i][signal].extremum = 0;
}
}
setntab(i, nst)
int i;
char *nst;
{
if (0 <= i && i < N_NTYPES) {
ntab[i].episodes = 0L;
ntab[i].duration = strtim("0.5");
ntab[i].nstring = nst;
}
}
bstats(i, s) /* print a line of the beat table if beats of type i were seen */
int i;
char *s; /* English description of beat type i */
{
if (btab[i].tcount > 0L || btab[i].lcount > 0L) {
printf("<tr align=right><td>%s</td>", s);
if (btab[i].lcount > 0L) {
printf("<td>%ld</td>", btab[i].lcount);
lsum += btab[i].lcount;
}
else
printf("<td>-</td>");
if (btab[i].tcount > 0L) {
printf("<td>%ld</td>", btab[i].tcount);
tsum += btab[i].tcount;
}
else
printf("<td>-</td>");
printf("<td>%ld</td></tr>\n", btab[i].lcount + btab[i].tcount);
}
}
aupdate(i) /* Record that an i-beat SV run was observed */
int i;
{
int j;
for (j = 0; j < N_RLEN-1; j++) {
if (artab[j].len == i) break;
else if (artab[j].len == 0) { artab[j].len = i; break; }
}
artab[j].nruns++;
}
vupdate(i) /* Record that an i-beat V run was observed */
int i;
{
int j;
for (j = 0; j < N_RLEN-1; j++) {
if (vrtab[j].len == i) break;
else if (vrtab[j].len == 0) { vrtab[j].len = i; break; }
}
vrtab[j].nruns++;
}
