30 #pragma optimize("",off)
114 plexit(
"alloc_line: Insufficient memory" );
120 if ( ( line->
x == NULL ) || ( line->
y == NULL ) )
122 plexit(
"alloc_line: Insufficient memory" );
138 plexit(
"alloc_level: Insufficient memory" );
150 if ( ( ( line->
x = (
PLFLT *) realloc( line->
x,
152 ( ( line->
y = (
PLFLT *) realloc( line->
y,
154 plexit(
"realloc_line: Insufficient memory" );
164 if ( startlev == NULL )
172 currlev = currlev->
next;
174 currline = currlev->
line;
190 cline = clevel->
line;
193 #ifdef CONT_PLOT_DEBUG // for 2D plots. For 3D plots look at plot3.c:plotsh3di()
195 for ( j = 1; j < cline->
npts; j++ )
204 while ( cline != NULL );
209 while ( clevel != NULL );
224 currline->
x[pts] = xx;
225 currline->
y[pts] = yy;
237 if ( currline->
npts != 0 )
240 currline = currline->
next;
270 PLFLT delta_x, delta_y;
271 PLINT currx_old, curry_old;
276 currx_old = plsc->currx;
277 curry_old = plsc->curry;
279 *distance += sqrt( delta_x * delta_x + delta_y * delta_y );
285 PLFLT scale, vec_x, vec_y, mx, my, dev_x, dev_y, off_x, off_y;
297 mx = (double) plsc->wpxscl / (
double) plsc->phyxlen;
298 my = (double) plsc->wpyscl / (
double) plsc->phyylen;
300 dev_x = -my * vec_y / mx;
301 dev_y = mx * vec_x / my;
303 scale = sqrt( ( mx * mx * dev_x * dev_x + my * my * dev_y * dev_y ) /
306 off_x = dev_x / scale;
307 off_y = dev_y / scale;
309 plptex( tpx + off_x, tpy + off_y, vec_x, vec_y, 0.5, flabel );
326 PLINT setpre, precis;
335 #define TMPSTRING_LEN 15
348 tmp = log10( value );
349 else if ( value < 0.0 )
350 tmp = log10( -value );
355 exponent = (int) tmp;
356 else if ( tmp < 0.0 )
359 if ( floor( tmp ) < tmp )
360 exponent = -(
int) ( floor( tmp ) + 1.0 );
362 exponent = -(int) ( floor( tmp ) );
365 mant = value / pow( 10.0, exponent );
368 mant = (int) ( mant * pow( 10.0, prec - 1 ) + 0.5 * mant / fabs( mant ) ) / pow( 10.0, prec - 1 );
371 snprintf(
string, (
size_t) len, form, mant );
373 strncat(
string, tmpstring, (
size_t) len - strlen(
string ) - 1 );
375 if ( abs( exponent ) <
limexp || value == 0.0 )
377 value = pow( 10.0, exponent ) * mant;
380 prec = prec - 1 - exponent;
382 prec = prec - 1 + abs( exponent );
388 snprintf(
string, (
size_t) len, form, value );
397 return ( ( x - plsc->wpxoff ) / plsc->wpxscl );
405 return ( ( y - plsc->wpyoff ) / plsc->wpyscl );
439 value = grid->
f[ix][iy];
458 value = grid->
f[ix * grid->
ny + iy];
477 value = grid->
f[ix + iy * grid->
nx];
500 plcont( f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
523 plabort(
"plcont: The pltr callback must be defined" );
528 nx, ny, kx, lx, ky, ly, clevel, nlevel,
559 if ( kx < 1 || kx >= lx )
561 plabort(
"plfcont: indices must satisfy 1 <= kx <= lx <= nx" );
564 if ( ky < 1 || ky >= ly )
566 plabort(
"plfcont: indices must satisfy 1 <= ky <= ly <= ny" );
570 if ( ( ipts = (
PLINT **) malloc( (
size_t) nx *
sizeof (
PLINT * ) ) ) == NULL )
572 plexit(
"plfcont: Insufficient memory" );
575 for ( i = 0; i <
nx; i++ )
577 if ( ( ipts[i] = (
PLINT *) malloc( (
size_t) ny *
sizeof (
PLINT * ) ) ) == NULL )
579 plexit(
"plfcont: Insufficient memory" );
583 for ( i = 0; i < nlevel; i++ )
585 plcntr( f2eval, f2eval_data,
586 nx, ny, kx - 1, lx - 1, ky - 1, ly - 1, clevel[i], ipts,
597 for ( i = 0; i <
nx; i++ )
599 free( (
void *) ipts[i] );
601 free( (
void *) ipts );
619 PLINT kcol, krow, lastindex;
621 PLFLT save_def, save_scale;
624 plgchr( &save_def, &save_scale );
625 save_scale = save_scale / save_def;
634 for ( kcol = kx; kcol < lx; kcol++ )
636 for ( krow = ky; krow < ly; krow++ )
638 ipts[kcol][krow] = 0;
643 for ( krow = ky; krow < ly; krow++ )
645 for ( kcol = kx; kcol < lx; kcol++ )
647 if ( ipts[kcol][krow] == 0 )
651 nx, ny, kx, lx, ky, ly, flev, flabel, kcol, krow,
652 0.0, 0.0, -2, ipts, &distance, &lastindex,
660 plschr( save_def, save_scale );
680 PLFLT px[4], py[4], locx[4], locy[4];
682 PLINT i, j, k, num, first, inext, kcolnext, krownext;
685 ( *pltr )( kcol, krow + 1, &px[0], &py[0], pltr_data );
686 ( *pltr )( kcol, krow, &px[1], &py[1], pltr_data );
687 ( *pltr )( kcol + 1, krow, &px[2], &py[2], pltr_data );
688 ( *pltr )( kcol + 1, krow + 1, &px[3], &py[3], pltr_data );
690 f[0] = f2eval( kcol, krow + 1, f2eval_data ) - flev;
691 f[1] = f2eval( kcol, krow, f2eval_data ) - flev;
692 f[2] = f2eval( kcol + 1, krow, f2eval_data ) - flev;
693 f[3] = f2eval( kcol + 1, krow + 1, f2eval_data ) - flev;
695 for ( i = 0, j = 1; i < 4; i++, j = ( j + 1 ) % 4 )
697 iedge[i] = ( f[i] * f[j] > 0.0 ) ? -1 : ( ( f[i] * f[j] < 0.0 ) ? 1 : 0 );
701 ipts[kcol][krow] = 1;
704 if ( ( iedge[0] == -1 ) && ( iedge[1] == -1 ) && ( iedge[2] == -1 )
705 && ( iedge[3] == -1 ) )
710 if ( ( f[0] == 0.0 ) && ( f[1] == 0.0 ) && ( f[2] == 0.0 ) &&
727 for ( k = 0, i = ( startedge < 0 ? 0 : startedge ); k < 4; k++, i = ( i + 1 ) % 4 )
729 if ( i == startedge )
733 if ( f[i] == 0.0 && f[( i + 1 ) % 4] == 0.0 )
745 if ( ( kcolnext < kx ) || ( kcolnext >= lx ) ||
746 ( krownext < ky ) || ( krownext >= ly ) ||
747 ( ipts[kcolnext][krownext] == 1 ) )
750 if ( ( iedge[i] == 1 ) || ( f[i] == 0.0 ) )
755 locx[num] = ( px[i] * fabs( f[j] ) + px[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
756 locy[num] = ( py[i] * fabs( f[j] ) + py[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
784 inext = ( i + 2 ) % 4;
793 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
794 ( krownext >= ky ) && ( krownext < ly ) &&
795 ( ipts[kcolnext][krownext] == 0 ) )
798 nx, ny, kx, lx, ky, ly, flev, flabel,
800 locx[num], locy[num], inext, ipts,
813 inext = ( i + 2 ) % 4;
816 kcolnext--; krownext++;
820 krownext--; kcolnext--;
824 kcolnext++; krownext--;
828 krownext++; kcolnext++;
830 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
831 ( krownext >= ky ) && ( krownext < ly ) &&
832 ( ipts[kcolnext][krownext] == 0 ) )
835 nx, ny, kx, lx, ky, ly, flev, flabel,
837 locx[num], locy[num], inext, ipts,
886 PLINT ul, ur, vl, vr;
904 if ( x < 0 || x > nx - 1 || y < 0 || y > ny - 1 )
906 plexit(
"pltr1: Invalid coordinates" );
924 *tx = xl * ( 1 - du ) + xr * du;
933 *ty = yl * ( 1 - dv ) + yr * dv;
953 PLINT ul, ur, vl, vr;
955 PLFLT xll, xlr, xrl, xrr;
956 PLFLT yll, ylr, yrl, yrr;
978 if ( x < xmin || x > xmax || y < ymin || y > ymax )
980 plwarn(
"pltr2: Invalid coordinates" );
1000 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1001 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1004 else if ( x > xmax )
1008 *tx = xg[nx - 1][0];
1009 *ty = yg[nx - 1][0];
1011 else if ( y > ymax )
1013 *tx = xg[nx - 1][ny - 1];
1014 *ty = yg[nx - 1][ny - 1];
1018 xll = xg[nx - 1][vl];
1019 yll = yg[nx - 1][vl];
1020 xlr = xg[nx - 1][vr];
1021 ylr = yg[nx - 1][vr];
1023 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1024 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1036 *tx = xll * ( 1 - du ) + xrl * ( du );
1037 *ty = yll * ( 1 - du ) + yrl * ( du );
1039 else if ( y > ymax )
1041 xlr = xg[ul][ny - 1];
1042 xrr = xg[ur][ny - 1];
1043 ylr = yg[ul][ny - 1];
1044 yrr = yg[ur][ny - 1];
1046 *tx = xlr * ( 1 - du ) + xrr * ( du );
1047 *ty = ylr * ( 1 - du ) + yrr * ( du );
1065 if ( ur == nx && vr < ny )
1070 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1071 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1076 else if ( ur < nx && vr == ny )
1081 *tx = xll * ( 1 - du ) + xrl * ( du );
1082 *ty = yll * ( 1 - du ) + yrl * ( du );
1087 else if ( ur == nx && vr == ny )
1105 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1106 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1108 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1109 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1125 PLINT ul, ur, vl, vr;
1127 PLFLT xll, xlr, xrl, xrr;
1128 PLFLT yll, ylr, yrl, yrr;
1150 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1152 plwarn(
"pltr2p: Invalid coordinates" );
1160 else if ( y > ymax )
1162 *tx = *( xg + ( ny - 1 ) );
1163 *ty = *( yg + ( ny - 1 ) );
1168 xll = *( xg + ul * ny + vl );
1169 yll = *( yg + ul * ny + vl );
1170 xlr = *( xg + ul * ny + vr );
1171 ylr = *( yg + ul * ny + vr );
1173 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1174 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1177 else if ( x > xmax )
1181 *tx = *( xg + ( ny - 1 ) * nx );
1182 *ty = *( yg + ( ny - 1 ) * nx );
1184 else if ( y > ymax )
1186 *tx = *( xg + ( ny - 1 ) + ( nx - 1 ) *
ny );
1187 *ty = *( yg + ( ny - 1 ) + ( nx - 1 ) *
ny );
1192 xll = *( xg + ul * ny + vl );
1193 yll = *( yg + ul * ny + vl );
1194 xlr = *( xg + ul * ny + vr );
1195 ylr = *( yg + ul * ny + vr );
1197 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1198 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1206 xll = *( xg + ul * ny + vl );
1207 xrl = *( xg + ur * ny + vl );
1208 yll = *( yg + ul * ny + vl );
1209 yrl = *( yg + ur * ny + vl );
1211 *tx = xll * ( 1 - du ) + xrl * ( du );
1212 *ty = yll * ( 1 - du ) + yrl * ( du );
1214 else if ( y > ymax )
1217 xlr = *( xg + ul * ny + vr );
1218 xrr = *( xg + ur * ny + vr );
1219 ylr = *( yg + ul * ny + vr );
1220 yrr = *( yg + ur * ny + vr );
1222 *tx = xlr * ( 1 - du ) + xrr * ( du );
1223 *ty = ylr * ( 1 - du ) + yrr * ( du );
1236 xll = *( xg + ul * ny + vl );
1237 yll = *( yg + ul * ny + vl );
1241 if ( ur == nx && vr < ny )
1243 xlr = *( xg + ul * ny + vr );
1244 ylr = *( yg + ul * ny + vr );
1246 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1247 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1252 else if ( ur < nx && vr == ny )
1254 xrl = *( xg + ur * ny + vl );
1255 yrl = *( yg + ur * ny + vl );
1257 *tx = xll * ( 1 - du ) + xrl * ( du );
1258 *ty = yll * ( 1 - du ) + yrl * ( du );
1263 else if ( ur == nx && vr == ny )
1273 xrl = *( xg + ur * ny + vl );
1274 xlr = *( xg + ul * ny + vr );
1275 xrr = *( xg + ur * ny + vr );
1277 yrl = *( yg + ur * ny + vl );
1278 ylr = *( yg + ul * ny + vr );
1279 yrr = *( yg + ur * ny + vr );
1281 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1282 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1284 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1285 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1306 PLINT ul, ur, vl, vr;
1308 PLFLT xll, xlr, xrl, xrr;
1309 PLFLT yll, ylr, yrl, yrr;
1331 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1333 plwarn(
"pltr2f: Invalid coordinates" );
1342 else if ( y > ymax )
1344 *tx = *( xg + ( ny - 1 ) * nx );
1345 *ty = *( yg + ( ny - 1 ) * nx );
1350 xll = *( xg + ul + vl *
nx );
1351 yll = *( yg + ul + vl *
nx );
1352 xlr = *( xg + ul + vr *
nx );
1353 ylr = *( yg + ul + vr *
nx );
1355 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1356 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1359 else if ( x > xmax )
1363 *tx = *( xg + ( nx - 1 ) );
1364 *ty = *( yg + ( nx - 1 ) );
1366 else if ( y > ymax )
1368 *tx = *( xg + ( nx - 1 ) + ( ny - 1 ) *
nx );
1369 *ty = *( yg + ( nx - 1 ) + ( ny - 1 ) *
nx );
1374 xll = *( xg + ul + vl *
nx );
1375 yll = *( yg + ul + vl *
nx );
1376 xlr = *( xg + ul + vr *
nx );
1377 ylr = *( yg + ul + vr *
nx );
1379 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1380 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1388 xll = *( xg + ul + vl *
nx );
1389 xrl = *( xg + ur + vl *
nx );
1390 yll = *( yg + ul + vl *
nx );
1391 yrl = *( yg + ur + vl *
nx );
1393 *tx = xll * ( 1 - du ) + xrl * ( du );
1394 *ty = yll * ( 1 - du ) + yrl * ( du );
1396 else if ( y > ymax )
1399 xlr = *( xg + ul + vr *
nx );
1400 xrr = *( xg + ur + vr *
nx );
1401 ylr = *( yg + ul + vr *
nx );
1402 yrr = *( yg + ur + vr *
nx );
1404 *tx = xlr * ( 1 - du ) + xrr * ( du );
1405 *ty = ylr * ( 1 - du ) + yrr * ( du );
1417 xll = *( xg + ul + vl *
nx );
1418 yll = *( yg + ul + vl *
nx );
1422 if ( ur == nx && vr < ny )
1424 xlr = *( xg + ul + vr *
nx );
1425 ylr = *( yg + ul + vr *
nx );
1427 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1428 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1433 else if ( ur < nx && vr == ny )
1435 xrl = *( xg + ur + vl *
nx );
1436 yrl = *( yg + ur + vl *
nx );
1438 *tx = xll * ( 1 - du ) + xrl * ( du );
1439 *ty = yll * ( 1 - du ) + yrl * ( du );
1444 else if ( ur == nx && vr == ny )
1454 xrl = *( xg + ur + vl *
nx );
1455 xlr = *( xg + ul + vr *
nx );
1456 xrr = *( xg + ur + vr *
nx );
1458 yrl = *( yg + ur + vl *
nx );
1459 ylr = *( yg + ul + vr *
nx );
1460 yrr = *( yg + ur + vr *
nx );
1461 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1462 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1464 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1465 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );