Back to index

plt-scheme  4.2.1
Defines | Functions | Variables
plline.c File Reference
#include "plplotP.h"

Go to the source code of this file.

Defines

#define INSIDE(ix, iy)   (BETW(ix,xmin,xmax) && BETW(iy,ymin,ymax))

Functions

static void pllclp (PLINT *x, PLINT *y, PLINT npts)
static int clipline (PLINT *p_x1, PLINT *p_y1, PLINT *p_x2, PLINT *p_y2, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax)
static void genlin (short *x, short *y, PLINT npts)
static void grdashline (short *x, short *y)
MZ_DLLEXPORT void c_pljoin (PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
MZ_DLLEXPORT void c_plline (PLINT n, PLFLT *x, PLFLT *y)
void c_plline3 (PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
MZ_DLLEXPORT void c_plpoly3 (PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT *draw, PLINT ifcc)
void c_plstyl (PLINT nms, PLINT *mark, PLINT *space)
void plP_movphy (PLINT x, PLINT y)
void plP_draphy (PLINT x, PLINT y)
void plP_movwor (PLFLT x, PLFLT y)
void plP_drawor (PLFLT x, PLFLT y)
void plP_draphy_poly (PLINT *x, PLINT *y, PLINT n)
void plP_drawor_poly (PLFLT *x, PLFLT *y, PLINT n)
void plP_pllclp (PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT))
void plP_plfclp (PLINT *x, PLINT *y, PLINT npts, PLINT xmin, PLINT xmax, PLINT ymin, PLINT ymax, void(*draw)(short *, short *, PLINT))

Variables

static PLINT xline [PL_MAXPOLY]
static PLINT yline [PL_MAXPOLY]
static PLINT lastx = PL_UNDEFINED
static PLINT lasty = PL_UNDEFINED

Define Documentation

#define INSIDE (   ix,
  iy 
)    (BETW(ix,xmin,xmax) && BETW(iy,ymin,ymax))

Definition at line 8 of file plline.c.


Function Documentation

MZ_DLLEXPORT void c_pljoin ( PLFLT  x1,
PLFLT  y1,
PLFLT  x2,
PLFLT  y2 
)

Definition at line 45 of file plline.c.

{
    plP_movwor(x1, y1);
    plP_drawor(x2, y2);
}

Here is the call graph for this function:

MZ_DLLEXPORT void c_plline ( PLINT  n,
PLFLT x,
PLFLT y 
)

Definition at line 59 of file plline.c.

{
    if (plsc->level < 3) {
       plabort("plline: Please set up window first");
       return;
    }
    plP_drawor_poly(x, y, n);
}

Here is the call graph for this function:

void c_plline3 ( PLINT  n,
PLFLT x,
PLFLT y,
PLFLT z 
)

Definition at line 79 of file plline.c.

{
    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;
}

Here is the call graph for this function:

MZ_DLLEXPORT void c_plpoly3 ( PLINT  n,
PLFLT x,
PLFLT y,
PLFLT z,
PLINT draw,
PLINT  ifcc 
)

Definition at line 195 of file plline.c.

{
    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*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 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;
}

Here is the call graph for this function:

void c_plstyl ( PLINT  nms,
PLINT mark,
PLINT space 
)

Definition at line 313 of file plline.c.

{
    short int i;

    if (plsc->level < 1) {
       plabort("plstyl: Please call plinit first");
       return;
    }
    if ((nms < 0) || (nms > 10)) {
       plabort("plstyl: Broken lines cannot have <0 or >10 elements");
       return;
    }
    for (i = 0; i < nms; i++) {
       if ((mark[i] < 0) || (space[i] < 0)) {
           plabort("plstyl: Mark and space lengths must be > 0");
           return;
       }
    }

    plsc->nms = nms;
    for (i = 0; i < nms; i++) {
       plsc->mark[i] = mark[i];
       plsc->space[i] = space[i];
    }

    plsc->curel = 0;
    plsc->pendn = 1;
    plsc->timecnt = 0;
    plsc->alarm = nms > 0 ? mark[0] : 0;
}

Here is the call graph for this function:

static int clipline ( PLINT p_x1,
PLINT p_y1,
PLINT p_x2,
PLINT p_y2,
PLINT  xmin,
PLINT  xmax,
PLINT  ymin,
PLINT  ymax 
) [static]

Definition at line 689 of file plline.c.

{
    PLINT t, dx, dy, flipx, flipy;
    double dydx = 0, dxdy = 0;

/* If both points are outside clip region with no hope of intersection,
   return with an error */

    if ((*p_x1 <= xmin && *p_x2 <= xmin) ||
       (*p_x1 >= xmax && *p_x2 >= xmax) ||
       (*p_y1 <= ymin && *p_y2 <= ymin) ||
       (*p_y1 >= ymax && *p_y2 >= ymax))
       return 1;

    flipx = 0;
    flipy = 0;

    if (*p_x2 < *p_x1) {
       *p_x1 = 2 * xmin - *p_x1;
       *p_x2 = 2 * xmin - *p_x2;
       xmax = 2 * xmin - xmax;
       t = xmax;
       xmax = xmin;
       xmin = t;
       flipx = 1;
    }

    if (*p_y2 < *p_y1) {
       *p_y1 = 2 * ymin - *p_y1;
       *p_y2 = 2 * ymin - *p_y2;
       ymax = 2 * ymin - ymax;
       t = ymax;
       ymax = ymin;
       ymin = t;
       flipy = 1;
    }

    dx = *p_x2 - *p_x1;
    dy = *p_y2 - *p_y1;

    if (dx != 0 && dy != 0) {
       dydx = (double) dy / (double) dx;
       dxdy = 1./ dydx;
    }

    if (*p_x1 < xmin) {
       if (dx != 0 && dy != 0)
           *p_y1 = *p_y1 + ROUND((xmin - *p_x1) * dydx);
       *p_x1 = xmin;
    }

    if (*p_y1 < ymin) {
       if (dx != 0 && dy != 0)
           *p_x1 = *p_x1 + ROUND((ymin - *p_y1) * dxdy);
       *p_y1 = ymin;
    }

    if (*p_x1 >= xmax || *p_y1 >= ymax)
       return 1;

    if (*p_y2 > ymax) {
       if (dx != 0 && dy != 0)
           *p_x2 = *p_x2 - ROUND((*p_y2 - ymax) * dxdy);
       *p_y2 = ymax;
    }

    if (*p_x2 > xmax) {
       if (dx != 0 && dy != 0)
           *p_y2 = *p_y2 - ROUND((*p_x2 - xmax) * dydx);
       *p_x2 = xmax;
    }

    if (flipx) {
       *p_x1 = 2 * xmax - *p_x1;
       *p_x2 = 2 * xmax - *p_x2;
    }

    if (flipy) {
       *p_y1 = 2 * ymax - *p_y1;
       *p_y2 = 2 * ymax - *p_y2;
    }

    return 0;
}

Here is the caller graph for this function:

static void genlin ( short *  x,
short *  y,
PLINT  npts 
) [static]

Definition at line 784 of file plline.c.

{
/* Check for solid line */

    if (plsc->nms == 0) {
       if (npts== 2)
           plP_line(x, y);
       else
           plP_polyline(x, y, npts);
    }

/* Right now dashed lines don't use polyline capability -- this
   should be improved */

    else {

       PLINT i;

        /* Call escape sequence to draw dashed lines, only for drivers
          that have this capability */
        if (plsc->dev_dash) {
           plsc->dev_npts = npts;
           plsc->dev_x = x;
           plsc->dev_y = y;
           plP_esc(PLESC_DASH, NULL);
            return;
        }

       for (i = 0; i < npts - 1; i++) {
           grdashline(x+i, y+i);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void grdashline ( short *  x,
short *  y 
) [static]

Definition at line 825 of file plline.c.

{
    PLINT nx, ny, nxp, nyp, incr, temp;
    PLINT modulo, dx, dy, i, xtmp, ytmp;
    PLINT tstep, pix_distance, j;
    int loop_x;
    short xl[2], yl[2];
    double nxstep, nystep;

/* Check if pattern needs to be restarted */

    if (x[0] != lastx || y[0] != lasty) {
       plsc->curel = 0;
       plsc->pendn = 1;
       plsc->timecnt = 0;
       plsc->alarm = plsc->mark[0];
    }

    lastx = xtmp = x[0];
    lasty = ytmp = y[0];

    if (x[0] == x[1] && y[0] == y[1])
       return;

    nx = x[1] - x[0];
    dx = (nx > 0) ? 1 : -1;
    nxp = ABS(nx);

    ny = y[1] - y[0];
    dy = (ny > 0) ? 1 : -1;
    nyp = ABS(ny);

    if (nyp > nxp) {
       modulo = nyp;
       incr = nxp;
       loop_x = 0;
    }
    else {
       modulo = nxp;
       incr = nyp;
       loop_x = 1;
    }

    temp = modulo / 2;

/* Compute the timer step */

    nxstep = nxp * plsc->umx;
    nystep = nyp * plsc->umy;
    tstep = sqrt( nxstep * nxstep + nystep * nystep ) / modulo;
    if (tstep < 1) tstep = 1;

    /* tstep is distance per pixel moved */

    i = 0;
    while (i < modulo) {
        pix_distance = (plsc->alarm - plsc->timecnt + tstep - 1) / tstep;
       i += pix_distance;
       if (i > modulo)
           pix_distance -= (i - modulo);
       plsc->timecnt += pix_distance * tstep;

       temp += pix_distance * incr;
       j = temp / modulo;
       temp = temp % modulo;

       if (loop_x) {
           xtmp += pix_distance * dx;
           ytmp += j * dy;
       }
       else {
           xtmp += j * dx;
           ytmp += pix_distance * dy;
       }
       if (plsc->pendn != 0) {
           xl[0] = lastx;
           yl[0] = lasty;
           xl[1] = xtmp;
           yl[1] = ytmp;
           plP_line(xl, yl);
       }

/* Update line style variables when alarm goes off */

       while (plsc->timecnt >= plsc->alarm) {
           if (plsc->pendn != 0) {
              plsc->pendn = 0;
              plsc->timecnt -= plsc->alarm;
              plsc->alarm = plsc->space[plsc->curel];
           }
           else {
              plsc->pendn = 1;
              plsc->timecnt -= plsc->alarm;
              plsc->curel++;
              if (plsc->curel >= plsc->nms)
                  plsc->curel = 0;
              plsc->alarm = plsc->mark[plsc->curel];
           }
       }
       lastx = xtmp;
       lasty = ytmp;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pllclp ( PLINT x,
PLINT y,
PLINT  npts 
) [static]

Definition at line 462 of file plline.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_draphy ( PLINT  x,
PLINT  y 
)

Definition at line 364 of file plline.c.

{
    xline[0] = plsc->currx;
    xline[1] = x;
    yline[0] = plsc->curry;
    yline[1] = y;

    pllclp(xline, yline, 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_draphy_poly ( PLINT x,
PLINT y,
PLINT  n 
)

Definition at line 413 of file plline.c.

{
    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] = x[j];
           yline[i] = y[j];
       }
       pllclp(xline, yline, ilim);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_drawor ( PLFLT  x,
PLFLT  y 
)

Definition at line 394 of file plline.c.

{
    xline[0] = plsc->currx;
    xline[1] = plP_wcpcx(x);
    yline[0] = plsc->curry;
    yline[1] = plP_wcpcy(y);

    pllclp(xline, yline, 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_drawor_poly ( PLFLT x,
PLFLT y,
PLINT  n 
)

Definition at line 438 of file plline.c.

{
    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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_movphy ( PLINT  x,
PLINT  y 
)

Definition at line 351 of file plline.c.

{
    plsc->currx = x;
    plsc->curry = y;
}

Here is the caller graph for this function:

void plP_movwor ( PLFLT  x,
PLFLT  y 
)

Definition at line 381 of file plline.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_plfclp ( PLINT x,
PLINT y,
PLINT  npts,
PLINT  xmin,
PLINT  xmax,
PLINT  ymin,
PLINT  ymax,
void(*)(short *, short *, PLINT draw 
)

Definition at line 546 of file plline.c.

{
    PLINT x1, x2, y1, y2;
    PLINT i, iclp = -1;
    short xclp[PL_MAXPOLY], yclp[PL_MAXPOLY];
    int drawable;

    for (i = 0; i < npts - 1; i++) {
       x1 = x[i];
       x2 = x[i + 1];
       y1 = y[i];
       y2 = y[i + 1];

       drawable = (INSIDE(x1, y1) && INSIDE(x2, y2));
       if ( ! drawable)
           drawable = ! clipline(&x1, &y1, &x2, &y2, xmin, xmax, ymin, ymax);

       if (drawable) {

/* Not first point.  If first point of this segment matches up to the
   previous point, just add it.  */

           if (iclp >= 0 && x1 == xclp[iclp] && y1 == yclp[iclp]) {
              iclp++;
              xclp[iclp] = x2;
              yclp[iclp] = y2;
           }

/* First point of polyline, OR . */

/* If not, we need to add both points, to connect the points in the
 * polygon along the clip boundary.  If any of the previous points were
 * outside one of the 4 corners, assume the corner was encircled and add
 * it first. 
 */
           else {
              iclp++;
              xclp[iclp] = x1;
              yclp[iclp] = y1;

              if ((x1 == xmin && y2 == ymin) ||
                  (x2 == xmin && y1 == ymin)) {
                  iclp++;
                  xclp[iclp] = xmin;
                  yclp[iclp] = ymin;
              }
              else if ((x1 == xmax && y2 == ymin) ||
                      (x2 == xmax && y1 == ymin)) {
                  iclp++;
                  xclp[iclp] = xmax;
                  yclp[iclp] = ymin;
              }
              else if ((x1 == xmax && y2 == ymax) ||
                      (x2 == xmax && y1 == ymax)) {
                  iclp++;
                  xclp[iclp] = xmax;
                  yclp[iclp] = ymax;
              }
              else if ((x1 == xmin && y2 == ymax) ||
                      (x2 == xmin && y1 == ymax)) {
                  iclp++;
                  xclp[iclp] = xmin;
                  yclp[iclp] = ymax;
              }
           /* Experimental code from way back.
              Polygon clipping is HARD.
              {
                  int j;
                  for (j = 0; j < i; j++) {
                     if (x[j] < xmin && y[j] < ymin) {
                         break;
                     }
                     else if (x[j] < xmin && y[j] > ymax) {
                         iclp++;
                         xclp[iclp] = xmin;
                         yclp[iclp] = ymax;
                         break;
                     }
                     else if (x[j] > xmax && y[j] < ymin) {
                         iclp++;
                         xclp[iclp] = xmax;
                         yclp[iclp] = ymin;
                         break;
                     }
                     else if (x[j] > xmax && y[j] > ymax) {
                         iclp++;
                         xclp[iclp] = xmax;
                         yclp[iclp] = ymax;
                         break;
                     }
                  }
              }
           */
              iclp++;
              xclp[iclp] = x2;
              yclp[iclp] = y2;
           }
       }
    }

/* Draw the sucker */

    if (iclp + 1 >= 2) {
       if ((xclp[0] == xmin && yclp[iclp] == ymin) ||
           (xclp[iclp] == xmin && yclp[0] == ymin)) {
           iclp++;
           xclp[iclp] = xmin;
           yclp[iclp] = ymin;
       }
       else if ((xclp[0] == xmax && yclp[iclp] == ymin) ||
               (xclp[iclp] == xmax && yclp[0] == ymin)) {
           iclp++;
           xclp[iclp] = xmax;
           yclp[iclp] = ymin;
       }
       else if ((xclp[0] == xmax && yclp[iclp] == ymax) ||
               (xclp[iclp] == xmax && yclp[0] == ymax)) {
           iclp++;
           xclp[iclp] = xmax;
           yclp[iclp] = ymax;
       }
       else if ((xclp[0] == xmin && yclp[iclp] == ymax) ||
               (xclp[iclp] == xmin && yclp[0] == ymax)) {
           iclp++;
           xclp[iclp] = xmin;
           yclp[iclp] = ymax;
       }
    }
    if (iclp + 1 >= 3) {
      if(draw)
       (*draw)(xclp, yclp, iclp + 1);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plP_pllclp ( PLINT x,
PLINT y,
PLINT  npts,
PLINT  xmin,
PLINT  xmax,
PLINT  ymin,
PLINT  ymax,
void(*)(short *, short *, PLINT draw 
)

Definition at line 475 of file plline.c.

{
    PLINT x1, x2, y1, y2;
    PLINT i, iclp = 0;
    short xclp[PL_MAXPOLY], yclp[PL_MAXPOLY];
    int drawable;

    for (i = 0; i < npts - 1; i++) {
       x1 = x[i];
       x2 = x[i + 1];
       y1 = y[i];
       y2 = y[i + 1];

       drawable = (INSIDE(x1, y1) && INSIDE(x2, y2));
       if ( ! drawable)
           drawable = ! clipline(&x1, &y1, &x2, &y2, xmin, xmax, ymin, ymax);

       if (drawable) {

/* First point of polyline. */

           if (iclp == 0) {
              xclp[iclp] = x1;
              yclp[iclp] = y1;
              iclp++;
              xclp[iclp] = x2;
              yclp[iclp] = y2;
           }

/* Not first point.  Check if first point of this segment matches up to 
   previous point, and if so, add it to the current polyline buffer. */

           else if (x1 == xclp[iclp] && y1 == yclp[iclp]) {
              iclp++;
              xclp[iclp] = x2;
              yclp[iclp] = y2;
           }

/* Otherwise it's time to start a new polyline */

           else {
              if (iclp + 1 >= 2)
                  (*draw)(xclp, yclp, iclp + 1);
              iclp = 0;
              xclp[iclp] = x1;
              yclp[iclp] = y1;
              iclp++;
              xclp[iclp] = x2;
              yclp[iclp] = y2;
           }
       }
    }

/* Handle remaining polyline */

    if (iclp + 1 >= 2)
       (*draw)(xclp, yclp, iclp + 1);

    plsc->currx = x[npts-1];
    plsc->curry = y[npts-1];
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

PLINT lastx = PL_UNDEFINED [static]

Definition at line 12 of file plline.c.

PLINT lasty = PL_UNDEFINED [static]

Definition at line 12 of file plline.c.

PLINT xline[PL_MAXPOLY] [static]

Definition at line 10 of file plline.c.

PLINT yline[PL_MAXPOLY] [static]

Definition at line 10 of file plline.c.