awpaeth@watcgl.UUCP (01/31/87)
This is a reposting of the StarChart software used in conjunction with
the Yale Bright Star Catalog to generate star atlas pages. This posting
includes the PostScript driver, plus drivers for Unix Pic/troff, Tektronix
and vanilla tty output. A man page and installation instructions are included.
# This is a shell archive. Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
#
# Wrapped by watcgl!awpaeth on Fri Jan 30 17:02:55 EST 1987
# Contents: Makefile README starchart.c starchart.h starchart.l starchartdsp.c
# starchartpic.c starchartpost.c starcharttek.c
echo x - Makefile
sed 's/^@//' > "Makefile" <<'@//E*O*F Makefile//'
CFLAGS = -O
moonphase: moonphase.c
cc $(CFLAGS) moonphase.c -lm -o /u/awpaeth/bin/moonphase
planet: planet.c
cc $(CFLAGS) planet.c -lm -o /u/awpaeth/bin/planet
startek: starchart.c starcharttek.c
cc $(CFLAGS) starchart.c starcharttek.c -lm -o /u/awpaeth/bin/startek
starpic: starchart.c starchartpic.c
cc $(CFLAGS) starchart.c starchartpic.c -lm -o /u/awpaeth/bin/starpic
starpost: starchart.c starchartpost.c
cc $(CFLAGS) starchart.c starchartpost.c -lm -o /u/awpaeth/bin/starpost
stardsp: starchart.c starchartdsp.c
cc $(CFLAGS) starchart.c starchartdsp.c -lm -o /u/awpaeth/bin/stardsp
all: moonphase\
planet\
startek\
starpic\
starpost\
stardsp
@//E*O*F Makefile//
chmod u=rw,g=rw,o=r Makefile
echo x - README
sed 's/^@//' > "README" <<'@//E*O*F README//'
Installation instructions:
[1]
Get the four pieces of the reduced Yale Star Catalog from net.sources
and save in this directory under the name "yale.star". You may choose
another directory, name, or path conventions for this large file, but
then you will have to change the #define constant near the beginning of
starchart.c.
Fine points
-----
The yale stuff was posted as five articles, each under 50K:
(1) Intro (2) Data 1-of-4 (3) Data 2-of-4 [SIC] (4) Data 3-of-4 (5) Data 4-of-4
Sites without much disk space may truncate the file at any point, as the
data is sorted in order of increasing intensity (as the programs expect)
User's with copies of the Yale Data may reformat into the condensed format.
This is described in the first posting, which is the overview of the data.
-----
[2]
Do a "make all" to compile all software. They are described in the man page
"starchart.l". All compile using starchart.c as the mainline, with device
driver specifics in modules of appropriate name.
[3]
You may now try "man test" to make an Orion pic file similar to the one
posted to the net recently. Or you may test by outputting to the display,
as described in the EXAMPLE section of the man page.
[4]
You can now delete the original shar file, plus this file.
NOTES:
Tty display users (*sigh*) may which to alter "stardsp" to output to the
display using an appropriate number of of rows and columns on the screen.
(Presently 31x79 for a 32x80 display. 23x79 is a bit sparse). Find the
ROWS and COLS #defines in starchartdsp.c and update. Or be really ambitious
and recode them as run time variables.
Tektroniks users may wish to alter scaling parameters based on the actual
physical dimensions of the display raster, to get the cleanest possible star
glyphs on output. The #defines XSCALE and YSCALE are the ratio (I've reduced
them to LCD) between your device X (or Y) coordinates, and true Tektroniks
coordinates (X=1024, Y=768). XSCALEI and YSCALEI are their inverses.
Pic file users: the #define PICFRAG can be adjusted downward (presently 8)
should your pic input overflow pic's buffers. This happens when a long
move,draw,draw,...,draw sequence happens. Smaler PICFRAGs make larger files,
by forming fragmented move,draw commands.
PostScript users: you may wish to play with th boiler-plate macros which
define star shapes (e.g. 's1' does first magnitude stars).
@//E*O*F README//
chmod u=rw,g=rw,o=r README
echo x - starchart.c
sed 's/^@//' > "starchart.c" <<'@//E*O*F starchart.c//'
/*
* starchart.c - draw yale star catalog on binary output device
*
* (c) copyright 1987 by Alan Paeth (awpaeth@watcgl)
*/
#include <stdio.h>
#include <math.h>
#include <strings.h>
#include "starchart.h"
#define STARFILE "/u/awpaeth/hobby/astro/yale.star"
#define PLANETFILE "/u/awpaeth/hobby/astro/planet.star"
#define DCOS(x) (cos((x)*3.14159265354/180.0))
#define MAX(a,b) ((a)>(b)?(a):(b))
double max(), modup(), moddown();
main(argc, argv)
int argc;
char *argv[];
{
double thumbscale;
vecopen();
chartparms(&master, atof(argv[1]), atof(argv[2]), atof(argv[3]));
thumbscale = MAX( atof(argv[3]) * 1.2, 10.0);
chartparms(&thumbnail, atof(argv[1]), atof(argv[2]), thumbscale);
chartall(&master);
chartall(&thumbnail);
chartlegend(&master, (argc >= 5) ? argv[4] : "LEGEND");
vecclose();
exit(0);
}
chartparms(chart, ra, decl, scl)
double ra, decl, scl;
map chart;
{
double adj, xscale;
chart->racen = ra * 360.0 / 24.0;
chart->dlcen = decl;
chart->scale = scl;
if (chart->scale == 0.0) chart->scale = 15.0;
chart->north = (chart->dlcen + chart->scale / 2.0);
chart->south = (chart->dlcen - chart->scale / 2.0);
/*
* xscale is other than chart->scale in order to widen the horizontal viewing
* area, which otherwise shrinks near the poles under Sanson's projection
* this happens in polar maps which do not span the celestial equator
*/
adj = 1.0;
if (chart->north * chart->south > 0.0)
adj = max(DCOS(chart->north), DCOS(chart->south));
xscale = chart->scale/adj;
chart->east = (chart->racen + xscale*chart->ww/chart->wh / 2.0);
chart->west = (chart->racen - xscale*chart->ww/chart->wh / 2.0);
chart->yscale = chart->wh / chart->scale;
}
chartlegend(chart, title)
map chart;
char *title;
{
char tstr[20], tstr2[20];
vecsize(14);
vecsyms(100, 220, title);
vecsize(10);
vecsyms( 20, 200, "= = = = = = = = = = = =");
vecsyms( 20, 180, "Right Ascension:");
rastr(tstr, chart->racen);
sprintf(tstr2, " %s", tstr);
vecsyms(260, 180, tstr2);
vecsyms( 20, 160, "Declination:");
declstr(tstr, chart->dlcen);
vecsyms(260, 160, tstr);
vecsyms( 20, 140, "Chart Scale:");
sprintf(tstr, "%.3f", chart->scale);
sprintf(tstr2, " %s", tstr);
vecsyms(260, 140, tstr2);
vecsyms( 20, 20, "= = = = = = = = = = = =");
vecsyms(115, 110, "<1.0");
vecsyms(115, 80, "<2.0");
vecsyms(115, 50, "<3.0");
vecsyms(260, 110, "<4.0");
vecsyms(260, 80, "<5.0");
vecsyms(260, 50, ">5.0");
drawstar( 65, 110, 0);
drawstar( 65, 80, 1);
drawstar( 65, 50, 2);
drawstar(240, 110, 3);
drawstar(240, 80, 4);
drawstar(240, 50, 5);
}
readstar(file, lat, lon, mag, code, subcode, label)
FILE *file;
double *lat, *lon, *mag;
char *code, *subcode, *label;
{
#define LINELEN 40
char sbuf[LINELEN];
double rah, ram, ras, dld, dlm, dl, inten;
fgets(sbuf, LINELEN, file);
if (feof(file)) return(1);
/*
* sscanf of floats is TOOO slow:
* sscanf(sbuf, "%2f%2f%2f%c%2f%2f%c%3f%c%c%s", ... );
* use alternate:
*/
#define F2(i) ((double)((sbuf[i]-'0')*10+sbuf[i+1]-'0'))
#define F3(i) ((double)((sbuf[i]-'0')*100+(sbuf[i+1]-'0')*10+sbuf[i+2]-'0'))
rah = F2(0);
ram = F2(2);
ras = F2(4);
dld = F2(7);
dlm = F2(9);
inten = F3(12);
code[0] = sbuf[15];
subcode[0] = sbuf[16];
label[0] = '\0';
strncat(label, &sbuf[17], strlen(&sbuf[17])-1);
#define DLDEGSEC 3600.0
#define DLMINSEC 60.0
#define RAHRSSEC 54000.0
#define RAMINSEC 900.0
#define RASECSEC 15.0
*lon = (RAHRSSEC*rah + RAMINSEC*ram + RASECSEC*ras)/DLDEGSEC;
dl = (DLDEGSEC*dld + DLMINSEC*dlm)/DLDEGSEC;
*lat = (sbuf[6] == '-') ? -dl : dl;
*mag = ((sbuf[11] == '-') ? -inten : inten)/100.0;
return(0);
}
xform(chart, lat, lon, xloc, yloc)
map chart;
double lat, lon;
int *xloc, *yloc;
{
/*
* This is Sanson's Sinusoidal projection. Its properties:
* (1) area preserving
* (2) preserves linearity along y axis (declination/azimuth)
*/
*xloc = chart->wx+chart->ww/2 + (chart->racen-lon)*chart->yscale*DCOS(lat);
*yloc = chart->wy + (int)((lat - chart->south) * chart->yscale);
}
chartall(chart)
map chart;
{
#define READMODE "r"
#define OPENFAIL 0
FILE *sfile, *pfile;
if ((sfile = fopen(STARFILE, READMODE)) == OPENFAIL)
die("open fail on %s", STARFILE);
chartoutline(chart);
chartgrid(chart);
chartobjects(chart, sfile);
fclose(sfile);
if ((pfile = fopen(PLANETFILE, READMODE)) != OPENFAIL)
{
chartobjects(chart, pfile);
fclose(pfile);
}
}
chartobjects(chart, file)
map chart;
FILE *file;
{
double lat, lon, mag;
char code[1], subcode[1], label[100];
int xloc, yloc;
for(;;)
{
if (readstar(file, &lat, &lon, &mag, code, subcode, label)) break;
if (mag > chart->maglim) break;
if ((chart->west < 0.0) && (lon>180.0)) lon -= 360.0;
if ((chart->east > 360.0) && (lon<180.0)) lon += 360.0;
if ( (lon >= chart->west) && (lon <= chart->east) &&
(lat >= chart->south) && (lat <= chart->north) )
{
xform(chart, lat, lon, &xloc, &yloc);
if (code[0] == 'S') drawstar(xloc, yloc, (int)(mag));
if (code[0] == 'P') drawP(xloc, yloc);
if (strlen(label))
{
vecsize(10);
vecsyms(xloc+8, yloc, label);
}
}
}
}
/*
* Chart Construction
*/
chartgrid(chart)
map chart;
{
charthgrid(chart, 15.0, 18);
charthgrid(chart, 5.0, 12);
charthgrid(chart, 1.0, 6);
chartvgrid(chart, 10.0, 18);
chartvgrid(chart, 5.0 , 12);
chartvgrid(chart, 1.0, 6);
}
chartoutline(chart)
map chart;
{
double start, inc;
int xloc, xloc2, yloc, yloc2, div, i;
xform(chart, chart->south, chart->west, &xloc, &yloc);
xform(chart, chart->south, chart->east, &xloc2, &yloc2);
vecmovedraw(xloc, yloc, xloc2, yloc2);
xform(chart, chart->north, chart->west, &xloc, &yloc);
xform(chart, chart->north, chart->east, &xloc2, &yloc2);
vecmovedraw(xloc, yloc, xloc2, yloc2);
inc = (chart->north - chart->south);
div = (int)(inc);
if (div < 1) div = 1;
inc /= div;
start = chart->south;
xform(chart, start, chart->west, &xloc, &yloc);
vecmove(xloc, yloc);
for (i=0; i < div; i++)
{
start += inc;
xform(chart, start, chart->west, &xloc, &yloc);
vecdraw(xloc, yloc);
}
start = chart->south;
xform(chart, start, chart->east, &xloc, &yloc);
vecmove(xloc, yloc);
for (i=0; i < div; i++)
{
start += inc;
xform(chart, start, chart->east, &xloc, &yloc);
vecdraw(xloc, yloc);
}
}
rastr(str, ra)
char *str;
double ra;
{
int hrs, min;
hrs = (int)(ra/15.0);
min = (int)((ra - hrs * 15.0) * 4.0);
sprintf(str, "%02dh", hrs);
if (min) sprintf(str, "%s%02dm", str, min);
}
declstr(str, dl)
char *str;
double dl;
{
int deg, min;
if (dl == 0.0) sprintf(str, "%s", " ");
else if (dl > 0.0) sprintf(str, "%s", "+");
else
{
sprintf(str, "%s", "-");
dl = -dl;
}
deg = (int)(dl);
min = (int)((dl - deg) * 60.0);
sprintf(str, "%s%02dd", str, deg);
if (min) sprintf(str, "%s%02dm", str, min);
}
charthgrid(chart, inc, hgt)
map chart;
double inc;
{
#define HTICKLIM 2
#define HTEXTLIM 80
double start, stop, ra;
int xloc, xloc2, yloc, xloc3, yloc3;
start = modup(chart->west, inc);
stop = moddown(chart->east, inc);
xform(chart, chart->south, start, &xloc, &yloc);
xform(chart, chart->south, start+inc, &xloc2, &yloc);
if (xloc - xloc2 > HTICKLIM)
for (ra = start; ra <= stop; ra += inc)
{
xform(chart, chart->south, ra, &xloc3, &yloc3);
vecmovedraw(xloc3, yloc3-hgt, xloc3, yloc3);
if (xloc - xloc2 > HTEXTLIM)
{
char tstr[20];
rastr(tstr, ra);
vecsize(10);
vecsyms(xloc3+2, yloc-17, tstr);
}
}
}
chartvgrid(chart, inc, wid)
map chart;
double inc;
{
#define VTICKLIM 2
#define VTEXTLIM 20
double start, stop, dl;
int xloc, yloc, yloc2, xloc3, yloc3;
start = modup(chart->south, inc);
stop = moddown(chart->north, inc);
xform(chart, start, chart->west, &xloc, &yloc);
xform(chart, start+inc, chart->west, &xloc, &yloc2);
if (yloc2 - yloc > VTICKLIM)
for (dl = start; dl <= stop; dl += inc)
{
xform(chart, dl, chart->west, &xloc3, &yloc3);
vecmovedraw(xloc3, yloc3, xloc3+wid, yloc3);
if (yloc2 - yloc > VTEXTLIM)
{
char tstr[20];
declstr(tstr, dl);
vecsize(10);
vecsyms(xloc3+24, yloc3, tstr);
}
}
}
/*
* General Utilities
*/
double max(a, b)
double a, b;
{
if (a>b) return(a);
return(b);
}
double modup(a, b)
double a, b;
{
double new;
new = ((double)((int)(a/b))*b);
if (new >= a) return(new);
return(new += b);
}
double moddown(a, b)
double a, b;
{
double new;
new = ((double)((int)(a/b))*b);
if (new <= a) return(new);
return (new -= b);
}
die(a,b)
char *a, *b;
{
fprintf(stderr,"Error: ");
fprintf(stderr,a,b);
fprintf(stderr,"\n");
exit(1);
}
@//E*O*F starchart.c//
chmod u=rw,g=rw,o=r starchart.c
echo x - starchart.h
sed 's/^@//' > "starchart.h" <<'@//E*O*F starchart.h//'
typedef struct
{
float racen, dlcen, scale;
float north, south, east, west;
float maglim;
int wx, wy, ww, wh;
float yscale;
} mapblock, *map;
extern mapblock master, thumbnail;
@//E*O*F starchart.h//
chmod u=rw,g=rw,o=r starchart.h
echo x - starchart.l
sed 's/^@//' > "starchart.l" <<'@//E*O*F starchart.l//'
@.TH starchart LOCAL 12/1/87
@.UC
@.SH NAME
stardsp, starpic, startek \- print astronomical star charts using Yale database
@.SH SYNOPSIS
These programs generate star charts based on data extracted from the Yale
public domain star catalog.
Output is to the terminal
@.RB ( stardsp ),
Unix PIC file
@.RB ( starpic )
or in Tektronix
vector format
@.RB ( startek ).
Star data is optionally overlayed with other cosmic objects, such as planets.
@.SH EXAMPLES
@.nf
# Orion: the belt lies near 5h40m in RA, just below the CE.
stardsp 5.6 -4.1 11.2 "Orion & belt" | more
@.fi
@.SH DESCRIPTION
The starchart center is specified by two parameters: floats defining Right
Ascension [0.0 to 24.0 hours] and Declination [-90.0 to +90.0 degrees].
An optional third parameter defines the N/S range of the output window, in
degrees of declination.
An optional fourth parameter gives a title.
@.PP
The software reads data from a local file
@.RB ( yale.star )
and optional planetary file
@.RB ( planet.star )
and clips to a rectangular (in RA and DEC) window.
Objects within this window are projected onto the output media, and displayed
using the appropriate glyphs.
Present implementations draw two viewports: a "master" chart plus a
"thumbnail" overview with low limiting magnitude.
Their location and the limiting magnitude is specified by records in
the device driver, allowing the chart layout be tuned on a per-device basis.
The output is annotated with viewport boundaries, a legend and axis labels.
@.PP
Sanson's sinusoidal projection is used to map coordinates.
This projection preserves both area and linearity in Declination (y axis).
It gives good conformality (angle correctness) near the equator, so it is
useful along the Ecliptic.
Lines of RA converge at the poles (unlike cylindrical projections),
though Cassiopeia and the Dipper reproduce well.
@.SH BUGS
No testing for bogus ranges and scales which may wrap the poles.
The present implementation expects
@.B yale.star
sorted by decreasing magnitude so that output is sequential, and then cuts off
below a limiting magnitude.
For more detailed charts spatial sorting is more appropriate.
@.SH AUTHOR
Alan Paeth, University of Waterloo (AWPaeth@watCGL)
@//E*O*F starchart.l//
chmod u=rw,g=r,o=r starchart.l
echo x - starchartdsp.c
sed 's/^@//' > "starchartdsp.c" <<'@//E*O*F starchartdsp.c//'
/*
* TTY Display driver for startchart.c mainline
*/
#include <stdio.h>
#include <ctype.h>
#include "starchart.h"
#define MAX(a,b) ((a)>(b)?(a):(b))
#define ROWS 31
#define COLS 79
/*
* Chart parameters (limiting magnitude and window x,y,w,h)
*/
mapblock thumbnail = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3.0, 420, 35, 480, 195, 0.0 };
mapblock master = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
4.9, 20, 265, 880, 500, 0.0 };
/*
* Generic Star Drawing Stuff
*/
static int oldx, oldy, scrx, scry;
static char **linevec;
vecopen()
{
int i;
linevec = (char**)(calloc(ROWS, sizeof(char*)));
for (i=0; i<ROWS; i++) linevec[i] = (char*)(calloc(COLS, sizeof(char)));
}
vecclose()
{
int i, j, k;
char c;
for (i=0; i<ROWS; i++)
{
for (j=COLS-1; j>0; j--) if (linevec[i][j]) break;
for (k=0; k<=j; k++) putchar((c=linevec[i][k]) ? c : ' ');
putchar('\n');
free(linevec[i]);
}
fflush(stdout);
free(linevec);
}
vecsize(points)
int points;
{
}
vecmove(x, y)
{
oldx = x;
oldy = y;
scrx = x*COLS/1024;
scry = (768-y)*ROWS/768;
}
vecdraw(x, y)
{
int dx, dy, savex, savey, i, steps;
char c;
savex = oldx;
savey = oldy;
dx = x-oldx;
dy = y-oldy;
c = (abs(dx) > abs(dy)) ? '-' : '|';
steps = MAX(MAX(abs(dx),abs(dy))/12, 1);
for(i=0; i<=steps; i++)
{
vecmove(savex+i*dx/steps,savey+i*dy/steps);
sym(c);
}
}
vecsyms(x, y, s)
char *s;
{
char c;
vecmove(x, y);
while(c = *s++)
{
sym(c);
scrx++;
}
}
vecmovedraw(x1, y1, x2, y2)
{
vecmove(x1, y1);
vecdraw(x2, y2);
}
drawP(x, y)
{
vecsyms(x, y, "P");
}
drawstar(x, y, mag)
{
switch (mag)
{
case -1: draw0(x, y); break;
case 0: draw0(x, y); break;
case 1: draw1(x, y); break;
case 2: draw2(x, y); break;
case 3: draw3(x, y); break;
case 4: draw4(x, y); break;
default: draw5(x, y); break;
}
}
draw0(x, y)
{
vecsyms(x, y, "O");
}
draw1(x, y)
{
vecsyms(x, y, "*");
}
draw2(x, y)
{
vecsyms(x, y, "o");
}
draw3(x, y)
{
vecsyms(x, y, "~");
}
draw4(x, y)
{
vecsyms(x, y, ",");
}
draw5(x, y)
{
vecsyms(x, y, ".");
}
char overwrite(under, over)
char under, over;
{
if (over == under) return(over);
if (!under) return(over);
if (!over) return(under);
if (isspace(under)) return(over);
if (isspace(over)) return(under);
if (isalnum(under) && !isalnum(over)) return(under);
if (!isalnum(under) && isalnum(over)) return(over);
if ((under == '-') && (over == '|')) return('+');
if ((under == '|') && (over == '-')) return('+');
if ((under == '+') && (over == '-')) return('+');
if ((under == '+') && (over == '|')) return('+');
if ((under == '-') && (over == '+')) return('+');
if ((under == '|') && (over == '+')) return('+');
if ((under == ',') && (over == '.')) return(';');
if ((under == '.') && (over == ',')) return(';');
if ((under == '.') && (over == '.')) return(':');
if ((under == '|') && (over == '.')) return('!');
if ((under == '|') && (over == ',')) return('!');
if ((under == '.') && (over == '|')) return('!');
if ((under == ',') && (over == '|')) return('!');
if ((under == '-') && (over == '~')) return('=');
if ((under == '~') && (over == '-')) return('=');
return(over);
}
sym(c)
char c;
{
if ( (scrx >= 0) && (scrx < COLS) && (scry >= 0) && (scry < ROWS) )
linevec[scry][scrx] = overwrite(linevec[scry][scrx], c );
}
@//E*O*F starchartdsp.c//
chmod u=rw,g=rw,o=r starchartdsp.c
echo x - starchartpic.c
sed 's/^@//' > "starchartpic.c" <<'@//E*O*F starchartpic.c//'
/*
* Unix Pic file format driver for startchart.c mainline
*/
#include <stdio.h>
#include "starchart.h"
#define PICFRAG 8 /* split long "move,draw,...,draw" strings for pic */
/*
* Chart parameters (limiting magnitude and window x,y,w,h)
*/
mapblock thumbnail = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3.2, 480, 0, 480, 240, 0.0 };
mapblock master = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
8.0, 0, 370, 960, 960, 0.0 };
/*
* Generic Star Drawing Stuff
*/
static int oldps, dcount;
#define PICSCALE (1.0/160.0) /* roughly 6.5/1024.0 */
float conv(i)
{
return(i*PICSCALE);
}
vecsize(newps)
int newps;
{
if (newps != oldps) printf("\n.ps %d", newps);
oldps = newps;
}
vecopen()
{
printf(".nf\n.ll 6.75i\n.po 0.75i\n.RT\n.PS");
vecsize(10);
printf("\n.tl'Database: \\fIYale Star Catalog\\fP'\\s18\\fBStarChart\\fP\\s0'Software: \\fIAWPaeth@watCGL\\fP'");
printf("\n.ll 7.25i");
}
vecclose()
{
printf("\n.PE\n");
fflush(stdout);
}
vecmove(x, y)
{
dcount = 0;
printf("\nline from %.3fi,%.3fi", conv(x), conv(y));
}
vecdraw(x, y)
{
dcount++;
printf(" to %.3fi,%.3fi", conv(x), conv(y));
if (dcount > PICFRAG) vecmove(x,y); /* must fragment long pic commands */
}
vecsyms(x, y, s)
char *s;
{
printf("\n\"\\ %s\" ljust at %.3fi,%.3fi", s, conv(x), conv(y));
}
vecmovedraw(x1, y1, x2, y2)
{
vecmove(x1, y1);
vecdraw(x2, y2);
}
drawP(x, y)
{
vecsize(10);
vecsyms(x, y, "P");
}
drawstar(x, y, mag)
{
switch (mag)
{
case -1: draw0(x, y); break;
case 0: draw0(x, y); break;
case 1: draw1(x, y); break;
case 2: draw2(x, y); break;
case 3: draw3(x, y); break;
case 4: draw4(x, y); break;
default: draw5(x, y); break;
}
}
vecsymcen(x, y, s)
char *s;
{
printf("\n\"%s\" at %.3fi,%.3fi", s, conv(x), conv(y));
}
draw0(x, y)
{
vecsize(18);
vecsymcen(x, y, "\\o'\\(bu+'");
}
draw1(x, y)
{
vecsize(16);
vecsymcen(x, y, "\\(bu");
}
draw2(x, y)
{
vecsize(12);
vecsymcen(x, y, "\\o'\\(bu+'");
}
draw3(x, y)
{
vecsize(10);
vecsymcen(x, y, "\\(bu");
}
draw4(x, y)
{
vecsize(8);
vecsymcen(x, y, "\\o'\\(bu+'");
}
draw5(x, y)
{
vecsize(6);
vecsymcen(x, y, "\\(bu");
}
@//E*O*F starchartpic.c//
chmod u=rw,g=rw,o=r starchartpic.c
echo x - starchartpost.c
sed 's/^@//' > "starchartpost.c" <<'@//E*O*F starchartpost.c//'
/*
* PostScript file format driver for startchart.c mainline
*/
#include <stdio.h>
#include "starchart.h"
/*
* Chart parameters (limiting magnitude and window x,y,w,h)
*/
mapblock thumbnail = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3.2, 480, 0, 480, 240, 0.0 };
mapblock master = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
8.0, 0, 370, 960, 960, 0.0 };
/*
* Generic Star Drawing Stuff
*/
#define PICSCALE (72.0/160.0) /* roughly 6.5 inches/1024.0 units */
static int oldps, vecstate;
out(s)
char *s;
{
printf("%s\n", s);
}
float conv(i)
{
return(i*PICSCALE+80); /* 1.1" margins left and bottom */
}
vecsize(newps)
int newps;
{
if (newps != oldps)
printf("/Times-Bold findfont %d scalefont setfont\n", newps);
oldps = newps;
}
vecopen()
{
out("%!PSAdobe-1.0");
out("%%Creator: AWPaeth@watCGL");
out("%%Title: StarChart");
out("%%Pages: 1");
out("%%DocumentFonts Times-Bold");
out("%%BoundingBox 0 0 612 792");
out("%%EndComments");
out("%%EndProlog");
out("%%Page: 0 1");
out("%");
out("% alias moveto/drawto");
out("%");
out("/mt {moveto} def");
out("/lt {lineto} def");
out("%");
out("% show: right, center, left adjust");
out("%");
out("/lshow {5 0 8#040 4 3 roll widthshow} def");
out("/cshow {dup stringwidth pop 2 div neg 0 rmoveto show} def");
out("/rshow {dup stringwidth pop neg 0 rmoveto show} def");
out("%");
out("% star/planet macros");
out("%");
out("/movereldraw {newpath 4 2 roll mt rlineto stroke} def");
out("/starplus {3 copy 0 movereldraw 3 copy 0 exch movereldraw");
out("neg 3 copy 0 movereldraw 3 copy 0 exch movereldraw} def");
out("/starbody {newpath 0 360 arc closepath fill} def");
out("/starbodyplus {3 copy starbody 1 add starplus} def");
out("/planet {2 copy newpath 2.5 0 360 arc closepath stroke 3.5 starplus} def");
out("%");
out("/s0 {4.5 starbodyplus} def");
out("/s1 {3.8 starbody} def");
out("/s2 {3.1 starbodyplus} def");
out("/s3 {2.4 starbody} def");
out("/s4 {1.7 starbodyplus} def");
out("/s5 {1.0 starbody} def");
out("%");
out("% alter line drawing defaults");
out("%");
out("0.5 setlinewidth 2 setlinecap");
out("%");
out("% boiler-plate");
out("%");
vecsize(10);
out(" 76 685 mt (Database: Yale Star Catalog) show");
out("548 685 mt (Software: AWPaeth@watCGL) rshow");
vecsize(18);
out("314 685 mt (StarChart) cshow");
vecsize(10);
out("%");
out("% THE STUFF");
out("%");
}
vecclose()
{
out("showpage");
out("%");
out("%%Trailer");
out("%%Pages: 1");
fflush(stdout);
}
vecmove(x, y)
{
if (vecstate==2) printf("stroke\n");
if (vecstate==2 || (vecstate == 0)) printf("newpath\n");
printf("%.1f %.1f mt\n", conv(x), conv(y));
vecstate = 1;
}
vecdraw(x, y)
{
printf("%.1f %.1f lt\n", conv(x), conv(y));
vecstate = 2;
}
vecsyms(x, y, s)
char *s;
{
vecmove(x,y-4);
printf("(%s) lshow\n", s);
}
vecmovedraw(x1, y1, x2, y2)
{
vecmove(x1, y1);
vecdraw(x2, y2);
}
drawP(x, y)
{
printf("%.1f %.1f planet\n", conv(x), conv(y));
}
drawstar(x, y, mag)
{
switch (mag)
{
case -1: draw0(x, y); break;
case 0: draw0(x, y); break;
case 1: draw1(x, y); break;
case 2: draw2(x, y); break;
case 3: draw3(x, y); break;
case 4: draw4(x, y); break;
default: draw5(x, y); break;
}
}
draw0(x, y)
{
vecsize(36);
printf("%.1f %.1f s0\n", conv(x), conv(y));
}
draw1(x, y)
{
vecsize(30);
printf("%.1f %.1f s1\n", conv(x), conv(y));
}
draw2(x, y)
{
vecsize(24);
printf("%.1f %.1f s2\n", conv(x), conv(y));
}
draw3(x, y)
{
vecsize(16);
printf("%.1f %.1f s3\n", conv(x), conv(y));
}
draw4(x, y)
{
vecsize(12);
printf("%.1f %.1f s4\n", conv(x), conv(y));
}
draw5(x, y)
{
vecsize(8);
printf("%.1f %.1f s5\n", conv(x), conv(y));
}
@//E*O*F starchartpost.c//
chmod u=rw,g=rw,o=r starchartpost.c
echo x - starcharttek.c
sed 's/^@//' > "starcharttek.c" <<'@//E*O*F starcharttek.c//'
/*
* Tektroniks driver for startchart.c mainline
*/
#include <stdio.h>
#include "starchart.h"
/*
* Chart parameters (limiting magnitude and window x,y,w,h)
*/
mapblock thumbnail = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3.2, 420, 35, 480, 195, 0.0 };
mapblock master = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
8.0, 20, 265, 880, 500, 0.0 };
/*
* Generic Star Drawing Stuff
*/
vecopen()
{
tekclear();
}
vecclose()
{
tekmove(0,0);
tekalpha();
fflush(stdout);
}
vecsize(points)
int points;
{
}
vecmove(x, y)
{
tekmove(x, y);
}
vecdraw(x, y)
{
tekdraw(x, y);
}
vecsym(x, y, s)
char s;
{
tekmove(x, y-11); /* center character strings */
tekalpha();
printf("%c",s);
}
vecsyms(x, y, s)
char *s;
{
tekmove(x, y-11); /* center character strings */
tekalpha();
printf(s);
}
vecmovedraw(x1, y1, x2, y2)
{
tekmove(x1, y1);
tekdraw(x2, y2);
fflush(stdout);
}
#define XSCALE 15/8
#define YSCALE 8/5
#define XSCALEI 8/15
#define YSCALEI 5/8
drawlen(x, y, dx, dy, len)
{
vecmovedraw((x*XSCALEI+dx)*XSCALE, (y*YSCALEI+dy)*YSCALE,
(x*XSCALEI+dx+len-1)*XSCALE+1, (y*YSCALEI+dy)*YSCALE);
}
drawP(x, y)
{
drawlen(x, y, -1, -2, 3); /* *** */
drawlen(x, y, -2, -1, 1); /* * * */
drawlen(x, y, 2, -1, 1);
drawlen(x, y, -2, 0, 1); /* * * * */
drawlen(x, y, 0, 0, 1);
drawlen(x, y, 2, 0, 1);
drawlen(x, y, -2, 1, 1); /* * * */
drawlen(x, y, 2, 1, 1);
drawlen(x, y, -1, 2, 3); /* *** */
}
drawstar(x, y, mag)
{
switch (mag)
{
case -1: draw0(x, y); break;
case 0: draw0(x, y); break;
case 1: draw1(x, y); break;
case 2: draw2(x, y); break;
case 3: draw3(x, y); break;
case 4: draw4(x, y); break;
default: draw5(x, y); break;
}
}
draw0(x, y)
{
drawlen(x, y, -2, -3, 5); /* ***** */
drawlen(x, y, -3, -2, 7); /* ******* */
drawlen(x, y, -3, -1, 3); /* *** *** */
drawlen(x, y, 1, -1, 3); /* ** ** */
drawlen(x, y, -3, 0, 2); /* *** *** */
drawlen(x, y, 2, 0, 2); /* ******* */
drawlen(x, y, 1, 1, 3); /* ***** */
drawlen(x, y, -3, 1, 3);
drawlen(x, y, -3, 2, 7);
drawlen(x, y, -2, 3, 5);
}
draw1(x, y)
{
drawlen(x, y, -1, -2, 3); /* *** */
drawlen(x, y, -2, -1, 5); /* ***** */
drawlen(x, y, -2, 0, 5); /* ***** */
drawlen(x, y, -2, 1, 5); /* ***** */
drawlen(x, y, -1, 2, 3); /* *** */
}
draw2(x, y)
{
drawlen(x, y, 0, -2, 1); /* * */
drawlen(x, y, -1, -1, 3); /* *** */
drawlen(x, y, -2, 0, 5); /* ***** */
drawlen(x, y, -1, 1, 3); /* *** */
drawlen(x, y, 0, 2, 1); /* * */
}
draw3(x, y)
{
drawlen(x, y, -1, -1, 3); /* *** */
drawlen(x, y, -1, 0, 3); /* *** */
drawlen(x, y, -1, 1, 3); /* *** */
}
draw4(x, y)
{
drawlen(x, y, 0, -1, 1); /* * */
drawlen(x, y, -1, 0, 3); /* *** */
drawlen(x, y, 0, 1, 1); /* * */
}
draw5(x, y)
{
drawlen(x, y, 0, 0, 1); /* * */
}
/*
* Low Level Tektronix Plotting Routines
*/
#define GS 035
#define US 037
#define ESC 033
#define FF 014
static int oldHiY = 0, oldLoY = 0, oldHiX = 0;
tekplot() /* switch to plot mode */
{
putchar(GS);
putchar('@');
oldHiY = oldLoY = oldHiX = 0;
}
tekalpha() /* switch to alpha mode */
{
putchar(US);
fflush(stdout);
}
tekclear()
{
putchar(ESC);
putchar(FF);
fflush(stdout);
}
tekmove(x, y) /* move to (x,y) */
{
putchar(GS);
tekdraw(x, y);
}
tekdraw(x, y) /* draw to (x,y) */
{
int hiY, loY, hiX, loX;
if (x < 0) x = 0;
if (y < 0) y = 0;
if (x > 1023) x = 1023;
if (y > 767) y = 767;
hiY = 0040 | (y>>5 & 037),
loY = 0140 | (y & 037),
hiX = 0040 | (x>>5 & 037),
loX = 0100 | (x & 037);
if (hiY != oldHiY) putchar(hiY);
if (loY != oldLoY || hiX != oldHiX) putchar(loY);
if (hiX != oldHiX) putchar(hiX);
putchar(loX);
oldHiY = hiY;
oldLoY = loY;
oldHiX = hiX;
}
@//E*O*F starcharttek.c//
chmod u=rw,g=rw,o=r starcharttek.c
exit 0