void
c_plscmap1(PLINT *r, PLINT *g, PLINT *b, PLINT ncol1)
{
int i;
plscmap1n(ncol1);
for (i = 0; i < plsc->ncol1; i++) {
if ((r[i] < 0 || r[i] > 255) ||
(g[i] < 0 || g[i] > 255) ||
(b[i] < 0 || b[i] > 255)) {
char buffer[256];
sprintf(buffer, "plscmap1: Invalid RGB color: %d, %d, %d",
(int) r[i], (int) g[i], (int) b[i]);
plabort(buffer);
return;
}
plsc->cmap1[i].r = r[i];
plsc->cmap1[i].g = g[i];
plsc->cmap1[i].b = b[i];
}
if (plsc->level > 0)
plP_state(PLSTATE_CMAP1);
}
void
c_plscol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
{
if (plsc->cmap0 == NULL)
plscmap0n(0);
if (icol0 < 0 || icol0 >= plsc->ncol0) {
char buffer[256];
sprintf(buffer, "plscol0: Illegal color table value: %d", (int) icol0);
plabort(buffer);
return;
}
if ((r < 0 || r > 255) || (g < 0 || g > 255) || (b < 0 || b > 255)) {
char buffer[256];
sprintf(buffer, "plscol0: Invalid RGB color: %d, %d, %d",
(int) r, (int) g, (int) b);
plabort(buffer);
return;
}
plsc->cmap0[icol0].r = r;
plsc->cmap0[icol0].g = g;
plsc->cmap0[icol0].b = b;
if (plsc->level > 0)
plP_state(PLSTATE_CMAP0);
}
void
c_plcol1(PLFLT col1)
{
PLINT icol1;
if (plsc->level < 1) {
plabort("plcol1: Please call plinit first");
return;
}
if (col1 < 0 || col1 > 1) {
char buffer[256];
sprintf(buffer, "plcol1: Invalid color map position: %f", (PLFLT) col1);
plabort(buffer);
return;
}
icol1 = col1 * plsc->ncol1;
icol1 = MIN(icol1, plsc->ncol1-1);
plsc->icol1 = icol1;
plsc->curcolor.r = plsc->cmap1[plsc->icol1].r;
plsc->curcolor.g = plsc->cmap1[plsc->icol1].g;
plsc->curcolor.b = plsc->cmap1[plsc->icol1].b;
plsc->curcmap = 1;
plP_state(PLSTATE_COLOR1);
}
void
c_plrgb(PLFLT r, PLFLT g, PLFLT b)
{
if (plsc->level < 1) {
plabort("plrgb: Please call plinit first");
return;
}
plsc->icol0 = PL_RGB_COLOR;
plsc->curcolor.r = MAX(0, MIN(255, (int) (256. * r)));
plsc->curcolor.g = MAX(0, MIN(255, (int) (256. * g)));
plsc->curcolor.b = MAX(0, MIN(255, (int) (256. * b)));
plsc->curcmap = 0;
plP_state(PLSTATE_COLOR0);
}
void
c_plrgb1(PLINT r, PLINT g, PLINT b)
{
if (plsc->level < 1) {
plabort("plrgb1: Please call plinit first");
return;
}
if ((r < 0 || r > 255) || (g < 0 || g > 255) || (b < 0 || b > 255)) {
plabort("plrgb1: Invalid color");
return;
}
plsc->icol0 = PL_RGB_COLOR;
plsc->curcolor.r = r;
plsc->curcolor.g = g;
plsc->curcolor.b = b;
plsc->curcmap = 0;
plP_state(PLSTATE_COLOR0);
}
void
c_plscmap0n(PLINT ncol0)
{
int ncol, size, imin, imax;
/* No change */
if (ncol0 > 0 && plsc->ncol0 == ncol0)
return;
/* Handle all possible startup conditions */
if (plsc->ncol0 <= 0 && ncol0 <= 0)
ncol = 16;
else if (ncol0 <= 0)
ncol = plsc->ncol0;
else
ncol = ncol0;
imax = ncol-1;
size = ncol * sizeof(PLColor);
/* Allocate the space */
if (plsc->cmap0 == NULL) {
plsc->cmap0 = (PLColor *) calloc(1, size);
imin = 0;
}
else {
plsc->cmap0 = (PLColor *) realloc(plsc->cmap0, size);
imin = plsc->ncol0;
}
/* Fill in default entries */
plsc->ncol0 = ncol;
plcmap0_def(imin, imax);
if (plsc->level > 0)
plP_state(PLSTATE_CMAP0);
}
void
c_plcol0(PLINT icol0)
{
if (plsc->level < 1) {
plabort("plcol0: Please call plinit first");
return;
}
if (icol0 < 0 || icol0 >= plsc->ncol0) {
char buffer[256];
sprintf(buffer, "plcol0: Invalid color map entry: %d", (int) icol0);
plabort(buffer);
return;
}
plsc->icol0 = icol0;
plsc->curcolor.r = plsc->cmap0[icol0].r;
plsc->curcolor.g = plsc->cmap0[icol0].g;
plsc->curcolor.b = plsc->cmap0[icol0].b;
plsc->curcmap = 0;
plP_state(PLSTATE_COLOR0);
}
void
c_plpsty(PLINT patt)
{
if (plsc->level < 1) {
plabort("plpsty: Please call plinit first");
return;
}
if (patt > 8) {
plabort("plpsty: Invalid pattern");
return;
}
if (patt != plsc->patt) {
plsc->patt = patt;
if (plsc->level > 0) {
plP_state(PLSTATE_FILL);
}
}
if (patt > 0) {
spat(&pattern[patt - 1].inc[0], &pattern[patt - 1].del[0],
pattern[patt - 1].nlines);
}
}
static void
plcmap1_def(void)
{
PLFLT i[6], h[6], l[6], s[6], midpt = 0., vertex = 0.;
/* Positions of control points */
i[0] = 0; /* left boundary */
i[1] = 0.44; /* a little left of center */
i[2] = 0.50; /* at center */
i[3] = 0.50; /* at center */
i[4] = 0.56; /* a little right of center */
i[5] = 1; /* right boundary */
/* For center control points, pick black or white, whichever is closer to bg */
/* Be carefult to pick just short of top or bottom else hue info is lost */
if (plsc->cmap0 != NULL)
vertex = ((PLFLT) plsc->cmap0[0].r +
(PLFLT) plsc->cmap0[0].g +
(PLFLT) plsc->cmap0[0].b) / 3. / 255.;
if (vertex < 0.5) {
vertex = 0.01;
midpt = 0.10;
} else {
vertex = 0.99;
midpt = 0.90;
}
/* Set hue */
h[0] = 260; /* low: blue-violet */
h[1] = 260; /* only change as we go over vertex */
h[2] = 260; /* only change as we go over vertex */
h[3] = 0; /* high: red */
h[4] = 0; /* high: red */
h[5] = 0; /* keep fixed */
/* Set lightness */
l[0] = 0.5; /* low */
l[1] = midpt; /* midpoint value */
l[2] = vertex; /* bg */
l[3] = vertex; /* bg */
l[4] = midpt; /* midpoint value */
l[5] = 0.5; /* high */
/* Set saturation -- keep at maximum */
s[0] = 1;
s[1] = 1;
s[2] = 1;
s[3] = 1;
s[4] = 1;
s[5] = 1;
c_plscmap1l(0, 6, i, h, l, s, NULL);
if (plsc->level > 0)
plP_state(PLSTATE_CMAP1);
}
void
plcmap1_calc(void)
{
int i, n;
PLFLT delta, dp, dh, dl, ds;
PLFLT h, l, s, p, r, g, b;
/* Loop over all control point pairs */
for (n = 0; n < plsc->ncp1-1; n++) {
if ( plsc->cmap1cp[n].p == plsc->cmap1cp[n+1].p )
continue;
/* Differences in p, h, l, s between ctrl pts */
dp = plsc->cmap1cp[n+1].p - plsc->cmap1cp[n].p;
dh = plsc->cmap1cp[n+1].h - plsc->cmap1cp[n].h;
dl = plsc->cmap1cp[n+1].l - plsc->cmap1cp[n].l;
ds = plsc->cmap1cp[n+1].s - plsc->cmap1cp[n].s;
/* Adjust dh if we are to go around "the back side" */
if (plsc->cmap1cp[n].rev)
dh = (dh > 0) ? dh-360 : dh+360;
/* Loop over all color cells. Only interested in cells located (in */
/* cmap1 space) between n_th and n+1_th control points */
for (i = 0; i < plsc->ncol1; i++) {
p = (double) i / (plsc->ncol1 - 1.0);
if ( (p < plsc->cmap1cp[n].p) ||
(p > plsc->cmap1cp[n+1].p) )
continue;
/* Interpolate based on position of color cell in cmap1 space */
delta = (p - plsc->cmap1cp[n].p) / dp;
/* Linearly interpolate to get color cell h, l, s values */
h = plsc->cmap1cp[n].h + dh * delta;
l = plsc->cmap1cp[n].l + dl * delta;
s = plsc->cmap1cp[n].s + ds * delta;
while (h >= 360.)
h -= 360.;
while (h < 0.)
h += 360.;
c_plhlsrgb(h, l, s, &r, &g, &b);
plsc->cmap1[i].r = MAX(0, MIN(255, (int) (256. * r)));
plsc->cmap1[i].g = MAX(0, MIN(255, (int) (256. * g)));
plsc->cmap1[i].b = MAX(0, MIN(255, (int) (256. * b)));
}
}
if (plsc->level > 0)
plP_state(PLSTATE_CMAP1);
}
static void
rdbuf_state(PLStream *pls)
{
U_CHAR op;
dbug_enter("rdbuf_state");
fread(&op, sizeof(U_CHAR), 1, pls->plbufFile);
switch (op) {
case PLSTATE_WIDTH:{
U_CHAR width;
fread(&width, sizeof(U_CHAR), 1, pls->plbufFile);
pls->width = width;
plP_state(PLSTATE_WIDTH);
break;
}
case PLSTATE_COLOR0:{
U_CHAR icol0, r, g, b;
fread(&icol0, sizeof(U_CHAR), 1, pls->plbufFile);
if (icol0 == PL_RGB_COLOR) {
fread(&r, sizeof(U_CHAR), 1, pls->plbufFile);
fread(&g, sizeof(U_CHAR), 1, pls->plbufFile);
fread(&b, sizeof(U_CHAR), 1, pls->plbufFile);
}
else {
if ((int) icol0 > 15) {
plwarn("rdbuf_state: Color map 0 entry hosed");
icol0 = 1;
}
r = pls->cmap0[icol0].r;
g = pls->cmap0[icol0].g;
b = pls->cmap0[icol0].b;
}
pls->icol0 = icol0;
pls->curcolor.r = r;
pls->curcolor.g = g;
pls->curcolor.b = b;
plP_state(PLSTATE_COLOR0);
break;
}
case PLSTATE_COLOR1: {
U_CHAR icol1;
fread(&icol1, sizeof(U_CHAR), 1, pls->plbufFile);
pls->icol1 = icol1;
pls->curcolor.r = pls->cmap1[icol1].r;
pls->curcolor.g = pls->cmap1[icol1].g;
pls->curcolor.b = pls->cmap1[icol1].b;
plP_state(PLSTATE_COLOR1);
break;
}
case PLSTATE_FILL: {
signed char patt;
fread(&patt, sizeof(signed char), 1, pls->plbufFile);
pls->patt = patt;
plP_state(PLSTATE_FILL);
break;
}
}
}
