28#pragma optimize("",off)
108 plexit(
"alloc_line: Insufficient memory" );
114 if ( (
line->x == NULL ) || (
line->y == NULL ) )
116 plexit(
"alloc_line: Insufficient memory" );
132 plexit(
"alloc_level: Insufficient memory" );
148 plexit(
"realloc_line: Insufficient memory" );
184 cline = clevel->
line;
187#ifdef CONT_PLOT_DEBUG
189 for ( j = 1; j < cline->
npts; j++ )
198 while ( cline != NULL );
203 while ( clevel != NULL );
264 PLFLT delta_x, delta_y;
265 PLINT currx_old, curry_old;
270 currx_old = plsc->currx;
271 curry_old = plsc->curry;
273 *
distance += sqrt( delta_x * delta_x + delta_y * delta_y );
279 PLFLT scale, vec_x, vec_y, mx, my, dev_x, dev_y, off_x, off_y;
291 mx = (double) plsc->wpxscl / (
double) plsc->phyxlen;
292 my = (double) plsc->wpyscl / (
double) plsc->phyylen;
294 dev_x = -my * vec_y / mx;
295 dev_y = mx * vec_x / my;
297 scale = sqrt( ( mx * mx * dev_x * dev_x + my * my * dev_y * dev_y ) /
300 off_x = dev_x / scale;
301 off_y = dev_y / scale;
303 plptex( tpx + off_x, tpy + off_y, vec_x, vec_y, 0.5, flabel );
320 PLINT setpre, precis;
329#define TMPSTRING_LEN 15
342 tmp = log10(
value );
343 else if (
value < 0.0 )
344 tmp = log10( -
value );
349 exponent = (int) tmp;
350 else if ( tmp < 0.0 )
353 if ( floor( tmp ) < tmp )
354 exponent = -(
int) ( floor( tmp ) + 1.0 );
356 exponent = -(int) ( floor( tmp ) );
359 mant =
value / pow( 10.0, exponent );
362 mant = (int) ( mant * pow( 10.0, prec - 1 ) + 0.5 * mant / fabs( mant ) ) / pow( 10.0, prec - 1 );
364 snprintf( form,
FORM_LEN,
"%%.%df", prec - 1 );
365 snprintf(
string, (
size_t) len, form, mant );
366 snprintf( tmpstring,
TMPSTRING_LEN,
"#(229)10#u%d", exponent );
367 strncat(
string, tmpstring, (
size_t) len - strlen(
string ) - 1 );
371 value = pow( 10.0, exponent ) * mant;
374 prec = prec - 1 - exponent;
376 prec = prec - 1 + abs( exponent );
381 snprintf( form,
FORM_LEN,
"%%.%df", (
int) prec );
382 snprintf(
string, (
size_t) len, form,
value );
391 return ( ( x - plsc->wpxoff ) / plsc->wpxscl );
399 return ( ( y - plsc->wpyoff ) / plsc->wpyscl );
452 value = grid->
f[ix * grid->ny + iy];
471 value = grid->
f[ix + iy * grid->nx];
493 plcont( f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
513 nx, ny, kx, lx, ky, ly, clevel, nlevel,
545 plabort(
"plfcont: The pltr callback must be defined" );
549 if ( kx < 1 || kx >= lx )
551 plabort(
"plfcont: indices must satisfy 1 <= kx <= lx <= nx" );
554 if ( ky < 1 || ky >= ly )
556 plabort(
"plfcont: indices must satisfy 1 <= ky <= ly <= ny" );
560 if ( ( ipts = (
PLINT **) malloc( (
size_t) nx *
sizeof (
PLINT * ) ) ) == NULL )
562 plexit(
"plfcont: Insufficient memory" );
565 for ( i = 0; i < nx; i++ )
567 if ( ( ipts[i] = (
PLINT *) malloc( (
size_t) ny *
sizeof (
PLINT * ) ) ) == NULL )
569 plexit(
"plfcont: Insufficient memory" );
573 for ( i = 0; i < nlevel; i++ )
575 plcntr( f2eval, f2eval_data,
576 nx, ny, kx - 1, lx - 1, ky - 1, ly - 1, clevel[i], ipts,
587 for ( i = 0; i < nx; i++ )
589 free( (
void *) ipts[i] );
591 free( (
void *) ipts );
607 PLINT kcol, krow, lastindex;
609 PLFLT save_def, save_scale;
612 plgchr( &save_def, &save_scale );
613 save_scale = save_scale / save_def;
622 for ( kcol = kx; kcol < lx; kcol++ )
624 for ( krow = ky; krow < ly; krow++ )
626 ipts[kcol][krow] = 0;
631 for ( krow = ky; krow < ly; krow++ )
633 for ( kcol = kx; kcol < lx; kcol++ )
635 if ( ipts[kcol][krow] == 0 )
639 nx, ny, kx, lx, ky, ly, flev, flabel, kcol, krow,
640 0.0, 0.0, -2, ipts, &
distance, &lastindex,
648 plschr( save_def, save_scale );
666 PLFLT px[4], py[4], locx[4], locy[4];
668 PLINT i, j, k, num, first, inext, kcolnext, krownext, sfi, sfj;
671 ( *pltr )( kcol, krow + 1, &px[0], &py[0], pltr_data );
672 ( *pltr )( kcol, krow, &px[1], &py[1], pltr_data );
673 ( *pltr )( kcol + 1, krow, &px[2], &py[2], pltr_data );
674 ( *pltr )( kcol + 1, krow + 1, &px[3], &py[3], pltr_data );
676 f[0] = f2eval( kcol, krow + 1, f2eval_data ) - flev;
677 f[1] = f2eval( kcol, krow, f2eval_data ) - flev;
678 f[2] = f2eval( kcol + 1, krow, f2eval_data ) - flev;
679 f[3] = f2eval( kcol + 1, krow + 1, f2eval_data ) - flev;
681 for ( i = 0, j = 1; i < 4; i++, j = ( j + 1 ) % 4 )
685 sfi = ( f[i] > 0.0 ) ? 1 : ( ( f[i] < 0.0 ) ? -1 : 0 );
686 sfj = ( f[j] > 0.0 ) ? 1 : ( ( f[j] < 0.0 ) ? -1 : 0 );
687 iedge[i] = ( sfi * sfj > 0 ) ? -1 : ( ( sfi * sfj < 0 ) ? 1 : 0 );
691 ipts[kcol][krow] = 1;
694 if ( ( iedge[0] == -1 ) && ( iedge[1] == -1 ) && ( iedge[2] == -1 )
695 && ( iedge[3] == -1 ) )
700 if ( ( f[0] == 0.0 ) && ( f[1] == 0.0 ) && ( f[2] == 0.0 ) &&
717 for ( k = 0, i = ( startedge < 0 ? 0 : startedge ); k < 4; k++, i = ( i + 1 ) % 4 )
719 if ( i == startedge )
723 if ( f[i] == 0.0 && f[( i + 1 ) % 4] == 0.0 )
735 if ( ( kcolnext < kx ) || ( kcolnext >= lx ) ||
736 ( krownext < ky ) || ( krownext >= ly ) ||
737 ( ipts[kcolnext][krownext] == 1 ) )
740 if ( ( iedge[i] == 1 ) || ( f[i] == 0.0 ) )
745 locx[num] = ( px[i] * fabs( f[j] ) + px[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
746 locy[num] = ( py[i] * fabs( f[j] ) + py[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
774 inext = ( i + 2 ) % 4;
783 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
784 ( krownext >= ky ) && ( krownext < ly ) &&
785 ( ipts[kcolnext][krownext] == 0 ) )
788 nx, ny, kx, lx, ky, ly, flev, flabel,
790 locx[num], locy[num], inext, ipts,
803 inext = ( i + 2 ) % 4;
806 kcolnext--; krownext++;
810 krownext--; kcolnext--;
814 kcolnext++; krownext--;
818 krownext++; kcolnext++;
820 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
821 ( krownext >= ky ) && ( krownext < ly ) &&
822 ( ipts[kcolnext][krownext] == 0 ) )
825 nx, ny, kx, lx, ky, ly, flev, flabel,
827 locx[num], locy[num], inext, ipts,
876 PLINT ul, ur, vl, vr;
878 PLFLT xl, xr, yl, yr;
882 PLFLT *yg = grid->yg;
894 if ( x < 0 || x > nx - 1 || y < 0 || y > ny - 1 )
896 plexit(
"pltr1: Invalid coordinates" );
914 *tx = xl * ( 1 - du ) + xr * du;
923 *ty = yl * ( 1 - dv ) + yr * dv;
943 PLINT ul, ur, vl, vr;
945 PLFLT xll, xlr, xrl, xrr;
946 PLFLT yll, ylr, yrl, yrr;
947 PLFLT xmin, xmax, ymin, ymax;
951 PLFLT **yg = grid->yg;
968 if ( x < xmin || x > xmax || y < ymin || y > ymax )
970 plwarn(
"pltr2: Invalid coordinates" );
990 *tx = xll * ( 1 - dv ) + xlr * ( dv );
991 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1001 else if ( y > ymax )
1003 *tx = xg[nx - 1][ny - 1];
1004 *ty = yg[nx - 1][ny - 1];
1008 xll = xg[nx - 1][vl];
1009 yll = yg[nx - 1][vl];
1010 xlr = xg[nx - 1][vr];
1011 ylr = yg[nx - 1][vr];
1013 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1014 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1026 *tx = xll * ( 1 - du ) + xrl * ( du );
1027 *ty = yll * ( 1 - du ) + yrl * ( du );
1029 else if ( y > ymax )
1031 xlr = xg[ul][ny - 1];
1032 xrr = xg[ur][ny - 1];
1033 ylr = yg[ul][ny - 1];
1034 yrr = yg[ur][ny - 1];
1036 *tx = xlr * ( 1 - du ) + xrr * ( du );
1037 *ty = ylr * ( 1 - du ) + yrr * ( du );
1055 if ( ur == nx && vr < ny )
1060 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1061 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1066 else if ( ur < nx && vr == ny )
1071 *tx = xll * ( 1 - du ) + xrl * ( du );
1072 *ty = yll * ( 1 - du ) + yrl * ( du );
1077 else if ( ur == nx && vr == ny )
1095 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1096 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1098 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1099 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1115 PLINT ul, ur, vl, vr;
1117 PLFLT xll, xlr, xrl, xrr;
1118 PLFLT yll, ylr, yrl, yrr;
1119 PLFLT xmin, xmax, ymin, ymax;
1123 PLFLT *yg = grid->yg;
1124 PLINT nx = grid->nx;
1125 PLINT ny = grid->ny;
1140 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1142 plwarn(
"pltr2p: Invalid coordinates" );
1150 else if ( y > ymax )
1152 *tx = *( xg + ( ny - 1 ) );
1153 *ty = *( yg + ( ny - 1 ) );
1158 xll = *( xg + ul * ny + vl );
1159 yll = *( yg + ul * ny + vl );
1160 xlr = *( xg + ul * ny + vr );
1161 ylr = *( yg + ul * ny + vr );
1163 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1164 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1167 else if ( x > xmax )
1171 *tx = *( xg + ( ny - 1 ) * nx );
1172 *ty = *( yg + ( ny - 1 ) * nx );
1174 else if ( y > ymax )
1176 *tx = *( xg + ( ny - 1 ) + ( nx - 1 ) * ny );
1177 *ty = *( yg + ( ny - 1 ) + ( nx - 1 ) * ny );
1182 xll = *( xg + ul * ny + vl );
1183 yll = *( yg + ul * ny + vl );
1184 xlr = *( xg + ul * ny + vr );
1185 ylr = *( yg + ul * ny + vr );
1187 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1188 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1196 xll = *( xg + ul * ny + vl );
1197 xrl = *( xg + ur * ny + vl );
1198 yll = *( yg + ul * ny + vl );
1199 yrl = *( yg + ur * ny + vl );
1201 *tx = xll * ( 1 - du ) + xrl * ( du );
1202 *ty = yll * ( 1 - du ) + yrl * ( du );
1204 else if ( y > ymax )
1207 xlr = *( xg + ul * ny + vr );
1208 xrr = *( xg + ur * ny + vr );
1209 ylr = *( yg + ul * ny + vr );
1210 yrr = *( yg + ur * ny + vr );
1212 *tx = xlr * ( 1 - du ) + xrr * ( du );
1213 *ty = ylr * ( 1 - du ) + yrr * ( du );
1226 xll = *( xg + ul * ny + vl );
1227 yll = *( yg + ul * ny + vl );
1231 if ( ur == nx && vr < ny )
1233 xlr = *( xg + ul * ny + vr );
1234 ylr = *( yg + ul * ny + vr );
1236 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1237 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1242 else if ( ur < nx && vr == ny )
1244 xrl = *( xg + ur * ny + vl );
1245 yrl = *( yg + ur * ny + vl );
1247 *tx = xll * ( 1 - du ) + xrl * ( du );
1248 *ty = yll * ( 1 - du ) + yrl * ( du );
1253 else if ( ur == nx && vr == ny )
1263 xrl = *( xg + ur * ny + vl );
1264 xlr = *( xg + ul * ny + vr );
1265 xrr = *( xg + ur * ny + vr );
1267 yrl = *( yg + ur * ny + vl );
1268 ylr = *( yg + ul * ny + vr );
1269 yrr = *( yg + ur * ny + vr );
1271 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1272 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1274 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1275 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1296 PLINT ul, ur, vl, vr;
1298 PLFLT xll, xlr, xrl, xrr;
1299 PLFLT yll, ylr, yrl, yrr;
1300 PLFLT xmin, xmax, ymin, ymax;
1321 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1323 plwarn(
"pltr2f: Invalid coordinates" );
1332 else if ( y > ymax )
1334 *tx = *( xg + ( ny - 1 ) * nx );
1335 *ty = *( yg + ( ny - 1 ) * nx );
1340 xll = *( xg + ul + vl * nx );
1341 yll = *( yg + ul + vl * nx );
1342 xlr = *( xg + ul + vr * nx );
1343 ylr = *( yg + ul + vr * nx );
1345 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1346 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1349 else if ( x > xmax )
1353 *tx = *( xg + ( nx - 1 ) );
1354 *ty = *( yg + ( nx - 1 ) );
1356 else if ( y > ymax )
1358 *tx = *( xg + ( nx - 1 ) + ( ny - 1 ) * nx );
1359 *ty = *( yg + ( nx - 1 ) + ( ny - 1 ) * nx );
1364 xll = *( xg + ul + vl * nx );
1365 yll = *( yg + ul + vl * nx );
1366 xlr = *( xg + ul + vr * nx );
1367 ylr = *( yg + ul + vr * nx );
1369 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1370 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1378 xll = *( xg + ul + vl * nx );
1379 xrl = *( xg + ur + vl * nx );
1380 yll = *( yg + ul + vl * nx );
1381 yrl = *( yg + ur + vl * nx );
1383 *tx = xll * ( 1 - du ) + xrl * ( du );
1384 *ty = yll * ( 1 - du ) + yrl * ( du );
1386 else if ( y > ymax )
1389 xlr = *( xg + ul + vr * nx );
1390 xrr = *( xg + ur + vr * nx );
1391 ylr = *( yg + ul + vr * nx );
1392 yrr = *( yg + ur + vr * nx );
1394 *tx = xlr * ( 1 - du ) + xrr * ( du );
1395 *ty = ylr * ( 1 - du ) + yrr * ( du );
1407 xll = *( xg + ul + vl * nx );
1408 yll = *( yg + ul + vl * nx );
1412 if ( ur == nx && vr < ny )
1414 xlr = *( xg + ul + vr * nx );
1415 ylr = *( yg + ul + vr * nx );
1417 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1418 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1423 else if ( ur < nx && vr == ny )
1425 xrl = *( xg + ur + vl * nx );
1426 yrl = *( yg + ur + vl * nx );
1428 *tx = xll * ( 1 - du ) + xrl * ( du );
1429 *ty = yll * ( 1 - du ) + yrl * ( du );
1434 else if ( ur == nx && vr == ny )
1444 xrl = *( xg + ur + vl * nx );
1445 xlr = *( xg + ul + vr * nx );
1446 xrr = *( xg + ur + vr * nx );
1448 yrl = *( yg + ur + vl * nx );
1449 ylr = *( yg + ul + vr * nx );
1450 yrr = *( yg + ur + vr * nx );
1451 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1452 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1454 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1455 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
static double distance(point *p1, point *p2)
static PLFLT plP_pcwcx(PLINT x)
static CONT_LEVEL * startlev
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
static PLFLT contlabel_size
static CONT_LINE * currline
void cont_clean_store(CONT_LEVEL *ct)
static CONT_LEVEL * alloc_level(PLFLT level)
static PLFLT contlabel_offset
static PLINT contlabel_active
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
static CONT_LINE * alloc_line(void)
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
static void realloc_line(CONT_LINE *line)
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
static void cont_xy_store(PLFLT xx, PLFLT yy)
static PLFLT contlabel_space
static void pl_drawcontlabel(PLFLT tpx, PLFLT tpy, char *flabel, PLFLT *distance, PLINT *lastindex)
static void cont_new_store(PLFLT level)
PLFLT plf2eval1(PLINT ix, PLINT iy, PLPointer plf2eval_data)
static CONT_LEVEL * currlev
static PLFLT plP_pcwcy(PLINT y)
static void cont_mv_store(PLFLT xx, PLFLT yy)
static void pldrawcn(PLF2EVAL_callback plf2eval, PLPointer plf2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT flev, char *flabel, PLINT kcol, PLINT krow, PLFLT lastx, PLFLT lasty, PLINT startedge, PLINT **ipts, PLFLT *distance, PLINT *lastindex, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void cont_store(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data, CONT_LEVEL **contour)
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
void plfcont(PLF2EVAL_callback f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
static void plcntr(PLF2EVAL_callback plf2eval, PLPointer plf2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT flev, PLINT **ipts, PLTRANSFORM_callback pltr, PLPointer pltr_data)
static void plfloatlabel(PLFLT value, char *string, PLINT len)
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
void plP_gprec(PLINT *p_setp, PLINT *p_prec)
void plwarn(PLCHAR_VECTOR errormsg)
static PLFLT value(double n1, double n2, double hue)
void plexit(PLCHAR_VECTOR errormsg)
void plabort(PLCHAR_VECTOR errormsg)
void plP_drawor(PLFLT x, PLFLT y)
void plP_movwor(PLFLT x, PLFLT y)
PLFLT(* PLF2EVAL_callback)(PLINT ix, PLINT iy, PLPointer data)
void(* PLTRANSFORM_callback)(PLFLT x, PLFLT y, PLFLT_NC_SCALAR xp, PLFLT_NC_SCALAR yp, PLPointer data)
const PLFLT * PLFLT_VECTOR
const PLFLT *const * PLFLT_MATRIX
static const char shade or gradient plots n n or n gradient plots(See pllegend for similar functionality for creating\n\ legends with discrete elements). The arguments of plcolorbar provide\n\ control over the location and size of the color bar as well as the\n\ location and characteristics of the elements(most of which are\n\ optional) within that color bar. The resulting color bar is clipped\n\ at the boundaries of the current subpage.(N.B. the adopted coordinate\n\ system used for some of the parameters is defined in the documentation\n\ of the position parameter.)\n\ \n\ Redacted form reads the desired grid location from the input vectors n xg[nptsx] and yg[nptsy]
static struct line line[]