void
c_plfill(PLINT n, PLFLT *x, PLFLT *y)
{
PLINT xpoly[PL_MAXPOLY], ypoly[PL_MAXPOLY];
PLINT i;
if (plsc->level < 3) {
plabort("plfill: Please set up window first");
return;
}
if (n < 3) {
plabort("plfill: Not enough points in object");
return;
}
if (n > PL_MAXPOLY-1) {
plwarn("plfill: too many points in polygon");
n = PL_MAXPOLY;
}
for (i = 0; i < n; i++) {
xpoly[i] = plP_wcpcx(x[i]);
ypoly[i] = plP_wcpcy(y[i]);
}
if (x[0] != x[n-1] || y[0] != y[n-1]) {
n++;
xpoly[n-1] = plP_wcpcx(x[0]);
ypoly[n-1] = plP_wcpcy(y[0]);
}
plP_plfclp(xpoly, ypoly, n, plsc->clpxmi, plsc->clpxma,
plsc->clpymi, plsc->clpyma, plP_fill);
}
static void
plery1(PLFLT x, PLFLT ymin, PLFLT ymax)
{
PLINT xminor;
xminor = MAX(1.0, plsc->minht * plsc->xpmm);
plP_movwor(x, ymin);
plytik(plP_wcpcx(x), plP_wcpcy(ymin), xminor, xminor);
plP_drawor(x, ymax);
plytik(plP_wcpcx(x), plP_wcpcy(ymax), xminor, xminor);
}
static void
plerx1(PLFLT xmin, PLFLT xmax, PLFLT y)
{
PLINT yminor;
yminor = MAX(1.0, plsc->minht * plsc->ypmm);
plP_movwor(xmin, y);
plxtik(plP_wcpcx(xmin), plP_wcpcy(y), yminor, yminor);
plP_drawor(xmax, y);
plxtik(plP_wcpcx(xmax), plP_wcpcy(y), yminor, yminor);
}
void
c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
{
PLINT i, sym, ifont = plsc->cfont;
PLFLT u, v;
PLFLT xmin, xmax, ymin, ymax, zmin, zmax, zscale;
if (plsc->level < 3) {
plabort("plpoin3: Please set up window first");
return;
}
if (code < -1 || code > 127) {
plabort("plpoin3: Invalid code");
return;
}
plP_gdom(&xmin, &xmax, &ymin, &ymax);
plP_grange(&zscale, &zmin, &zmax);
if (code == -1) {
for (i = 0; i < n; i++) {
if(x[i] >= xmin && x[i] <= xmax &&
y[i] >= ymin && y[i] <= ymax &&
z[i] >= zmin && z[i] <= zmax) {
u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
plP_movphy(u,v);
plP_draphy(u,v);
}
}
}
else {
if (ifont > numberfonts)
ifont = 1;
sym = *(fntlkup + (ifont - 1) * numberchars + code);
for( i=0; i < n; i++ ) {
if(x[i] >= xmin && x[i] <= xmax &&
y[i] >= ymin && y[i] <= ymax &&
z[i] >= zmin && z[i] <= zmax) {
u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
plhrsh(sym, u, v);
}
}
}
return;
}
//--------------------------------------------------------------------------
// void plwytik()
//
// Draws a tick parallel to y, using world coordinates
//--------------------------------------------------------------------------
void
plwytik( PLFLT x, PLFLT y, PLBOOL minor, PLBOOL invert )
{
PLINT length, below, above;
PLFLT height;
if ( minor )
{
// Minor tick
height = plsc->minht;
}
else
{
// Major tick
height = plsc->majht;
}
length = MAX( ROUND( height * plsc->xpmm ), 1 );
if ( invert )
{
below = 0;
above = length;
}
else
{
below = length;
above = 0;
}
// Actually draw the tick
plytik( plP_wcpcx( x ), plP_wcpcy( y ), below, above );
}
void
c_plfill3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
{
PLFLT tx[PL_MAXPOLY], ty[PL_MAXPOLY], tz[PL_MAXPOLY];
PLFLT *V[3];
PLINT xpoly[PL_MAXPOLY], ypoly[PL_MAXPOLY];
PLINT i;
PLFLT xmin, xmax, ymin, ymax, zmin, zmax, zscale;
if (plsc->level < 3) {
plabort("plfill3: Please set up window first");
return;
}
if (n < 3) {
plabort("plfill3: Not enough points in object");
return;
}
if (n > PL_MAXPOLY-1) {
plwarn("plfill3: too many points in polygon");
n = PL_MAXPOLY;
}
plP_gdom(&xmin, &xmax, &ymin, &ymax);
plP_grange(&zscale, &zmin, &zmax);
/* copy the vertices so we can clip without corrupting the input */
for( i=0; i < n; i++ ) {
tx[i] = x[i]; ty[i] = y[i]; tz[i] = z[i];
}
if (tx[0] != tx[n-1] || ty[0] != ty[n-1] || tz[0] != tz[n-1]) {
tx[n] = tx[0]; ty[n] = ty[0]; tz[n] = tz[0];
n++;
}
V[0] = tx; V[1] = ty; V[2] = tz;
n = plP_clip_poly(n, V, 0, 1, -xmin);
n = plP_clip_poly(n, V, 0, -1, xmax);
n = plP_clip_poly(n, V, 1, 1, -ymin);
n = plP_clip_poly(n, V, 1, -1, ymax);
n = plP_clip_poly(n, V, 2, 1, -zmin);
n = plP_clip_poly(n, V, 2, -1, zmax);
for( i=0; i < n; i++ ) {
xpoly[i] = plP_wcpcx(plP_w3wcx( tx[i], ty[i], tz[i] ));
ypoly[i] = plP_wcpcy(plP_w3wcy( tx[i], ty[i], tz[i] ));
}
/* AWI: in the past we have used
* plP_fill(xpoly, ypoly, n);
* here, but our educated guess is this fill should be done via the clipping
* interface instead as below.
* No example tests this code so one of our users will end up inadvertently
* testing this for us.
*
* jc: I have checked, and both versions does give the same result, i.e., clipping
* to the window boundaries. The reason is that the above plP_clip_poly() does
* the clipping. To check this, is enough to diminish the x/y/z min/max arguments in
* plw3d() in x08c. But let's keep it, although 10% slower...
*/
plP_plfclp(xpoly, ypoly, n, plsc->clpxmi, plsc->clpxma,
plsc->clpymi, plsc->clpyma, plP_fill);
}
void
c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
{
PLINT i, sym, ifont = plsc->cfont;
if (plsc->level < 3) {
plabort("plpoin: Please set up window first");
return;
}
if (code < -1 || code > 127) {
plabort("plpoin: Invalid code");
return;
}
if (code == -1) {
for (i = 0; i < n; i++)
pljoin(x[i], y[i], x[i], y[i]);
}
else {
if (ifont > numberfonts)
ifont = 1;
sym = *(fntlkup + (ifont - 1) * numberchars + code);
for (i = 0; i < n; i++)
plhrsh(sym, plP_wcpcx(x[i]), plP_wcpcy(y[i]));
}
}
/*
* Plot an individual vector
*/
static void
plP_plotvect(PLFLT x, PLFLT y, PLFLT u, PLFLT v, PLFLT scale) {
PLFLT uu, vv, px0, py0, dpx, dpy;
PLINT *a_x, *a_y;
int j;
uu = scale*u;
vv = scale*v;
if(uu == 0.0 && vv == 0.0) return;
if (((a_x = (PLINT *)malloc(sizeof(PLINT)*(plsc->arrow_npts)))==NULL)||
((a_y = (PLINT *)malloc(sizeof(PLINT)*(plsc->arrow_npts)))==NULL))
{
plexit("plP_plotvect: Insufficient memory");
}
px0 = plP_wcpcx(x);
py0 = plP_wcpcy(y);
pldebug("plP_plotvect", "%f %f %d %d\n",x,y,px0,py0);
dpx = plP_wcpcx(x + 0.5*uu) - px0;
dpy = plP_wcpcy(y + 0.5*vv) - py0;
/* transform arrow -> a */
for (j = 0; j < plsc->arrow_npts; j++) {
a_x[j] = (PLINT)(plsc->arrow_x[j] * dpx - plsc->arrow_y[j] * dpy + px0);
a_y[j] = (PLINT)(plsc->arrow_x[j] * dpy + plsc->arrow_y[j] * dpx + py0);
}
/* draw the arrow */
plP_draphy_poly(a_x,a_y,plsc->arrow_npts);
if (plsc->arrow_fill) {
plP_plfclp(a_x, a_y, plsc->arrow_npts, plsc->clpxmi, plsc->clpxma,
plsc->clpymi, plsc->clpyma, plP_fill);
}
free((void *)a_x);
free((void *)a_y);
}
void
plP_drawor(PLFLT x, PLFLT y)
{
xline[0] = plsc->currx;
xline[1] = plP_wcpcx(x);
yline[0] = plsc->curry;
yline[1] = plP_wcpcy(y);
pllclp(xline, yline, 2);
}
void
plP_drawor_poly(PLFLT *x, PLFLT *y, PLINT n)
{
PLINT i, j, ib, ilim;
for (ib = 0; ib < n; ib += PL_MAXPOLY - 1) {
ilim = MIN(PL_MAXPOLY, n - ib);
for (i = 0; i < ilim; i++) {
j = ib + i;
xline[i] = plP_wcpcx(x[j]);
yline[i] = plP_wcpcy(y[j]);
}
pllclp(xline, yline, ilim);
}
}
static void pl_drawcontlabel(PLFLT tpx, PLFLT tpy, char *flabel, PLFLT *distance, PLINT *lastindex)
{
PLFLT currx_old, curry_old, delta_x, delta_y;
delta_x = plP_pcdcx(plsc->currx)-plP_pcdcx(plP_wcpcx(tpx));
delta_y = plP_pcdcy(plsc->curry)-plP_pcdcy(plP_wcpcy(tpy));
currx_old = plsc->currx;
curry_old = plsc->curry;
*distance += sqrt(delta_x*delta_x + delta_y*delta_y);
plP_drawor(tpx, tpy);
if ((int )(fabs(*distance/contlabel_space)) > *lastindex) {
PLFLT scale, vec_x, vec_y, mx, my, dev_x, dev_y, off_x, off_y;
vec_x = tpx-plP_pcwcx(currx_old);
vec_y = tpy-plP_pcwcy(curry_old);
/* Ensure labels appear the right way up */
if (vec_x < 0) {
vec_x = -vec_x;
vec_y = -vec_y;
}
mx = (double )plsc->wpxscl/(double )plsc->phyxlen;
my = (double )plsc->wpyscl/(double )plsc->phyylen;
dev_x = -my*vec_y/mx;
dev_y = mx*vec_x/my;
scale = sqrt((mx*mx*dev_x*dev_x + my*my*dev_y*dev_y)/
(contlabel_offset*contlabel_offset));
off_x = dev_x/scale;
off_y = dev_y/scale;
plptex(tpx+off_x, tpy+off_y, vec_x, vec_y, 0.5, flabel);
plP_movwor(tpx, tpy);
(*lastindex)++;
} else
plP_movwor(tpx, tpy);
}
void
c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
{
PLINT i;
if (plsc->level < 3) {
plabort("plsym: Please set up window first");
return;
}
if (code < 0) {
plabort("plsym: Invalid code");
return;
}
for (i = 0; i < n; i++)
{
plhrsh(code, plP_wcpcx(x[i]), plP_wcpcy(y[i]));
}
}
void
plP_movwor(PLFLT x, PLFLT y)
{
plsc->currx = plP_wcpcx(x);
plsc->curry = plP_wcpcy(y);
}
static void
plxybx(const char *opt, const char *label, PLFLT wx1, PLFLT wy1,
PLFLT wx2, PLFLT wy2, PLFLT vmin_in, PLFLT vmax_in,
PLFLT tick, PLINT nsub, PLINT nolast, PLINT *digits)
{
static char string[40];
PLINT lb, lf, li, ll, ln, ls, lt, lu;
PLINT major, minor, mode, prec, scale;
PLINT i, i1, i2, i3, i4;
PLINT nsub1;
PLFLT pos, tn, tp, temp, height, tick1, vmin, vmax;
/* Note that 'tspace' is the minimim distance away (in fractional number
* of ticks) from the boundary that an X or Y numerical label can be drawn. */
PLFLT dwx, dwy, lambda, tcrit, tspace = 0.1;
vmin = (vmax_in > vmin_in) ? vmin_in : vmax_in;
vmax = (vmax_in > vmin_in) ? vmax_in : vmin_in;
dwx = wx2 - wx1;
dwy = wy2 - wy1;
/* Tick and subtick sizes in device coords */
major = MAX(ROUND(plsc->majht * plsc->ypmm), 1);
minor = MAX(ROUND(plsc->minht * plsc->ypmm), 1);
tick1 = tick;
nsub1 = nsub;
lb = plP_stsearch(opt, 'b');
lf = plP_stsearch(opt, 'f');
li = plP_stsearch(opt, 'i');
ll = plP_stsearch(opt, 'l');
ln = plP_stsearch(opt, 'n');
ls = plP_stsearch(opt, 's');
lt = plP_stsearch(opt, 't');
lu = plP_stsearch(opt, 'u');
if (lu)
plxytx(wx1, wy1, wx2, wy2, 3.2, 0.5, 0.5, label);
if (!lb)
return;
if (ll)
tick1 = (vmax > vmin) ? 1.0 : -1.0 ;
if (lt)
pldtik(vmin, vmax, &tick1, &nsub1);
if (li) {
i1 = minor;
i2 = 0;
i3 = major;
i4 = 0;
}
else {
i1 = 0;
i2 = minor;
i3 = 0;
i4 = major;
}
/* Draw the line */
plP_movwor(wx1, wy1);
if (lt) {
tp = tick1 * floor(vmin / tick1);
for (;;) {
tn = tp + tick1;
if (ls) {
if (ll) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vmin, vmax)) {
lambda = (vmax_in > vmin_in)?
(temp - vmin) / (vmax - vmin):
(vmax - temp) / (vmax - vmin);
plxtik(plP_wcpcx((PLFLT) (wx1 + lambda * dwx)),
plP_wcpcy((PLFLT) (wy1 + lambda * dwy)),
i1, i2);
}
}
}
else {
for (i = 1; i <= nsub1 - 1; i++) {
temp = tp + i * (tn - tp) / nsub1;
if (BETW(temp, vmin, vmax)) {
lambda = (vmax_in > vmin_in)?
(temp - vmin) / (vmax - vmin):
(vmax - temp) / (vmax - vmin);
plxtik(plP_wcpcx((PLFLT) (wx1 + lambda * dwx)),
plP_wcpcy((PLFLT) (wy1 + lambda * dwy)),
i1, i2);
}
}
}
}
temp = tn;
if (!BETW(temp, vmin, vmax))
break;
lambda = (vmax_in > vmin_in)?
(temp - vmin) / (vmax - vmin):
(vmax - temp) / (vmax - vmin);
plxtik(plP_wcpcx((PLFLT) (wx1 + lambda * dwx)),
plP_wcpcy((PLFLT) (wy1 + lambda * dwy)), i3, i4);
tp = tn;
}
}
plP_drawor(wx2, wy2);
/* Label the line */
if (ln && lt) {
pldprec(vmin, vmax, tick1, lf, &mode, &prec, *digits, &scale);
pos = 1.0;
height = 3.2;
tcrit = tspace*tick1;
tp = tick1 * (1. + floor(vmin / tick1));
for (tn = tp; BETW(tn, vmin, vmax); tn += tick1) {
if(BETW(tn, vmin+tcrit, vmax-tcrit)) {
plform(tn, scale, prec, string, ll, lf);
pos = (vmax_in > vmin_in)?
(tn - vmin) / (vmax - vmin):
(vmax - tn) / (vmax - vmin);
plxytx(wx1, wy1, wx2, wy2, 1.5, pos, 0.5, string);
}
}
*digits = 2;
if (!ll && mode) {
sprintf(string, "(x10#u%d#d)", (int) scale);
plxytx(wx1, wy1, wx2, wy2, height, 1.0, 0.5, string);
}
}
}
void
c_plaxes(PLFLT x0, PLFLT y0,
const char *xopt, PLFLT xtick, PLINT nxsub,
const char *yopt, PLFLT ytick, PLINT nysub)
{
PLINT lax, lbx, lcx, lgx, lix, llx, lsx, ltx;
PLINT lay, lby, lcy, lgy, liy, lly, lsy, lty;
PLINT xmajor, xminor, ymajor, yminor;
PLINT i, i1x, i2x, i3x, i4x, i1y, i2y, i3y, i4y;
PLINT nxsub1, nysub1;
PLINT lxmin, lxmax, lymin, lymax;
PLINT pxmin, pxmax, pymin, pymax;
PLINT vppxmi, vppxma, vppymi, vppyma;
PLFLT xtick1, ytick1, vpwxmi, vpwxma, vpwymi, vpwyma;
PLFLT vpwxmin, vpwxmax, vpwymin, vpwymax;
PLFLT xp0, yp0, tn, tp, temp;
if (plsc->level < 3) {
plabort("plbox: Please set up window first");
return;
}
/* Open the clip limits to the subpage limits */
plP_gclp(&lxmin, &lxmax, &lymin, &lymax);
plP_gphy(&pxmin, &pxmax, &pymin, &pymax);
plP_sclp(pxmin, pxmax, pymin, pymax);
vppxmi = plsc->vppxmi;
vppxma = plsc->vppxma;
vppymi = plsc->vppymi;
vppyma = plsc->vppyma;
/* Convert world coordinates to physical */
xp0 = plP_wcpcx(x0);
yp0 = plP_wcpcy(y0);
/* Set plot options from input */
lax = plP_stsearch(xopt, 'a');
lbx = plP_stsearch(xopt, 'b');
lcx = plP_stsearch(xopt, 'c');
lgx = plP_stsearch(xopt, 'g');
lix = plP_stsearch(xopt, 'i');
llx = plP_stsearch(xopt, 'l');
lsx = plP_stsearch(xopt, 's');
ltx = plP_stsearch(xopt, 't');
lay = plP_stsearch(yopt, 'a');
lby = plP_stsearch(yopt, 'b');
lcy = plP_stsearch(yopt, 'c');
lgy = plP_stsearch(yopt, 'g');
liy = plP_stsearch(yopt, 'i');
lly = plP_stsearch(yopt, 'l');
lsy = plP_stsearch(yopt, 's');
lty = plP_stsearch(yopt, 't');
/* Tick and subtick sizes in device coords */
xmajor = MAX(ROUND(plsc->majht * plsc->ypmm), 1);
ymajor = MAX(ROUND(plsc->majht * plsc->xpmm), 1);
xminor = MAX(ROUND(plsc->minht * plsc->ypmm), 1);
yminor = MAX(ROUND(plsc->minht * plsc->xpmm), 1);
nxsub1 = nxsub;
nysub1 = nysub;
xtick1 = llx ? 1.0 : xtick;
ytick1 = lly ? 1.0 : ytick;
plgvpw(&vpwxmin, &vpwxmax, &vpwymin, &vpwymax);
/* n.b. large change; vpwxmi always numerically less than vpwxma, and
* similarly for vpwymi */
vpwxmi = (vpwxmax > vpwxmin) ? vpwxmin : vpwxmax;
vpwxma = (vpwxmax > vpwxmin) ? vpwxmax : vpwxmin;
vpwymi = (vpwymax > vpwymin) ? vpwymin : vpwymax;
vpwyma = (vpwymax > vpwymin) ? vpwymax : vpwymin;
lax = lax && vpwymi < y0 && y0 < vpwyma ;
lay = lay && vpwxmi < x0 && x0 < vpwxma ;
/* Calculate tick spacing */
if (ltx || lgx)
pldtik(vpwxmi, vpwxma, &xtick1, &nxsub1);
if (lty || lgy)
pldtik(vpwymi, vpwyma, &ytick1, &nysub1);
/* n.b. large change; xtick1, nxsub1, ytick1, nysub1 always positive. */
/* Set up tick variables */
if (lix) {
i1x = xminor;
i2x = 0;
i3x = xmajor;
i4x = 0;
}
else {
i1x = 0;
i2x = xminor;
i3x = 0;
i4x = xmajor;
}
if (liy) {
i1y = yminor;
i2y = 0;
i3y = ymajor;
i4y = 0;
}
else {
i1y = 0;
i2y = yminor;
i3y = 0;
i4y = ymajor;
}
/* Draw the bottom edge of the box */
if (lbx) {
plP_movphy(vppxmi, vppymi);
if (ltx) {
tp = xtick1 * floor(vpwxmi / xtick1);
for (;;) {
tn = tp + xtick1;
if (lsx) {
if (llx) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppymi, i1x, i2x);
}
}
else {
for (i = 1; i <= nxsub1 - 1; i++) {
temp = tp + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppymi, i1x, i2x);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), vppymi, i3x, i4x);
tp = tn;
}
}
plP_draphy(vppxma, vppymi);
}
/* Draw right-hand edge of box */
if (lcy) {
plP_movphy(vppxma, vppymi);
if (lty) {
tp = ytick1 * floor(vpwymi / ytick1);
for (;;) {
tn = tp + ytick1;
if (lsy) {
if (lly) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxma, plP_wcpcy(temp), i2y, i1y);
}
}
else {
for (i = 1; i <= nysub1 - 1; i++) {
temp = tp + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxma, plP_wcpcy(temp), i2y, i1y);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(vppxma, plP_wcpcy(tn), i4y, i3y);
tp = tn;
}
}
plP_draphy(vppxma, vppyma);
}
/* Draw the top edge of the box */
if (lcx) {
plP_movphy(vppxma, vppyma);
if (ltx) {
tp = xtick1 * (floor(vpwxma / xtick1) + 1);
for (;;) {
tn = tp - xtick1;
if (lsx) {
if (llx) {
for (i = 7; i >= 0; i--) {
temp = tn + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppyma, i2x, i1x);
}
}
else {
for (i = nxsub1 - 1; i >= 1; i--) {
temp = tn + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppyma, i2x, i1x);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), vppyma, i4x, i3x);
tp = tn;
}
}
plP_draphy(vppxmi, vppyma);
}
/* Draw left-hand edge of box */
if (lby) {
plP_movphy(vppxmi, vppyma);
if (lty) {
tp = ytick1 * (floor(vpwyma / ytick1) + 1);
for (;;) {
tn = tp - ytick1;
if (lsy) {
if (lly) {
for (i = 7; i >= 0; i--) {
temp = tn + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxmi, plP_wcpcy(temp), i1y, i2y);
}
}
else {
for (i = nysub1 - 1; i >= 1; i--) {
temp = tn + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxmi, plP_wcpcy(temp), i1y, i2y);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(vppxmi, plP_wcpcy(tn), i3y, i4y);
tp = tn;
}
}
plP_draphy(vppxmi, vppymi);
}
/* Draw the horizontal axis */
if (lax) {
plP_movphy(vppxmi, yp0);
if (ltx) {
tp = xtick1 * floor(vpwxmi / xtick1);
for (;;) {
tn = tp + xtick1;
if (lsx) {
if (llx) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), yp0, xminor, xminor);
}
}
else {
for (i = 1; i <= nxsub1 - 1; i++) {
temp = tp + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), yp0, xminor, xminor);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), yp0, xmajor, xmajor);
tp = tn;
}
}
plP_draphy(vppxma, yp0);
}
/* Draw the vertical axis */
if (lay) {
plP_movphy(xp0, vppymi);
if (lty) {
tp = ytick1 * floor(vpwymi / ytick1);
for (;;) {
tn = tp + ytick1;
if (lsy) {
if (lly) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(xp0, plP_wcpcy(temp), yminor, yminor);
}
}
else {
for (i = 1; i <= nysub1 - 1; i++) {
temp = tp + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(xp0, plP_wcpcy(temp), yminor, yminor);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(xp0, plP_wcpcy(tn), ymajor, ymajor);
tp = tn;
}
}
plP_draphy(xp0, vppyma);
}
/* Draw grids */
grid_box(xopt, xtick1, nxsub1, yopt, ytick1, nysub1);
/* Write labels */
label_box(xopt, xtick1, yopt, ytick1);
/* Restore the clip limits to viewport edge */
plP_sclp(lxmin, lxmax, lymin, lymax);
}
/*----------------------------------------------------------------------*\
* void plline3(n, x, y, z)
*
* Draws a line in 3 space. You must first set up the viewport, the
* 2d viewing window (in world coordinates), and the 3d normalized
* coordinate box. See x18c.c for more info.
*
* This version adds clipping against the 3d bounding box specified in plw3d
\*----------------------------------------------------------------------*/
void
c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
{
int i;
PLFLT vmin[3], vmax[3], zscale;
if (plsc->level < 3) {
plabort("plline3: Please set up window first");
return;
}
/* get the bounding box in 3d */
plP_gdom(&vmin[0], &vmax[0], &vmin[1], &vmax[1]);
plP_grange(&zscale, &vmin[2], &vmax[2]);
/* interate over the vertices */
for( i=0; i < n-1; i++ ) {
PLFLT p0[3], p1[3];
int axis;
/* copy the end points of the segment to allow clipping */
p0[0] = x[i]; p0[1] = y[i]; p0[2] = z[i];
p1[0] = x[i+1]; p1[1] = y[i+1]; p1[2] = z[i+1];
/* check against each axis of the bounding box */
for(axis = 0; axis < 3; axis++) {
if(p0[axis] < vmin[axis]) { /* first out */
if(p1[axis] < vmin[axis]) {
break; /* both endpoints out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] < vmin[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
if(p0[axis] > vmax[axis]) { /* first out */
if(p1[axis] > vmax[axis]) {
break; /* both out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] > vmax[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
}
/* if we made it to here without "break"ing out of the loop, the
remaining segment is visible */
if( axis == 3 ) { /* not clipped away */
PLFLT u0, v0, u1, v1;
u0 = plP_wcpcx(plP_w3wcx( p0[0], p0[1], p0[2] ));
v0 = plP_wcpcy(plP_w3wcy( p0[0], p0[1], p0[2] ));
u1 = plP_wcpcx(plP_w3wcx( p1[0], p1[1], p1[2] ));
v1 = plP_wcpcy(plP_w3wcy( p1[0], p1[1], p1[2] ));
plP_movphy(u0,v0);
plP_draphy(u1,v1);
}
}
return;
}
void
c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
{
int i;
PLFLT vmin[3], vmax[3], zscale;
PLFLT u1, v1, u2, v2, u3, v3;
PLFLT c;
if (plsc->level < 3) {
plabort("plpoly3: Please set up window first");
return;
}
if ( n < 3 ) {
plabort("plpoly3: Must specify at least 3 points");
return;
}
/* Now figure out which side this is. */
u1 = plP_wcpcx(plP_w3wcx( x[0], y[0], z[0] ));
v1 = plP_wcpcy(plP_w3wcy( x[0], y[0], z[0] ));
u2 = plP_wcpcx(plP_w3wcx( x[1], y[1], z[1] ));
v2 = plP_wcpcy(plP_w3wcy( x[1], y[1], z[1] ));
u3 = plP_wcpcx(plP_w3wcx( x[2], y[2], z[2] ));
v3 = plP_wcpcy(plP_w3wcy( x[2], y[2], z[2] ));
c = (u1-u2)*(v3-v2)-(v1-v2)*(u3-u2);
if ( c *(1 - 2*ABS(ifcc)) < 0. )
return;
/* get the bounding box in 3d */
plP_gdom(&vmin[0], &vmax[0], &vmin[1], &vmax[1]);
plP_grange(&zscale, &vmin[2], &vmax[2]);
/* interate over the vertices */
for( i=0; i < n-1; i++ ) {
PLFLT p0[3], p1[3];
int axis;
/* copy the end points of the segment to allow clipping */
p0[0] = x[i]; p0[1] = y[i]; p0[2] = z[i];
p1[0] = x[i+1]; p1[1] = y[i+1]; p1[2] = z[i+1];
/* check against each axis of the bounding box */
for(axis = 0; axis < 3; axis++) {
if(p0[axis] < vmin[axis]) { /* first out */
if(p1[axis] < vmin[axis]) {
break; /* both endpoints out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] < vmin[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
if(p0[axis] > vmax[axis]) { /* first out */
if(p1[axis] > vmax[axis]) {
break; /* both out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] > vmax[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
}
/* if we made it to here without "break"ing out of the loop, the
remaining segment is visible */
if( axis == 3 && draw[i] ) { /* not clipped away */
PLFLT myu0, myv0, myu1, myv1;
myu0 = plP_wcpcx(plP_w3wcx( p0[0], p0[1], p0[2] ));
myv0 = plP_wcpcy(plP_w3wcy( p0[0], p0[1], p0[2] ));
myu1 = plP_wcpcx(plP_w3wcx( p1[0], p1[1], p1[2] ));
myv1 = plP_wcpcy(plP_w3wcy( p1[0], p1[1], p1[2] ));
plP_movphy(myu0,myv0);
plP_draphy(myu1,myv1);
}
}
return;
}
