28 #pragma optimize("",off)
112 plexit(
"alloc_line: Insufficient memory" );
118 if ( ( line->
x == NULL ) || ( line->
y == NULL ) )
120 plexit(
"alloc_line: Insufficient memory" );
136 plexit(
"alloc_level: Insufficient memory" );
148 if ( ( ( line->
x = (
PLFLT *) realloc( line->
x,
150 ( ( line->
y = (
PLFLT *) realloc( line->
y,
152 plexit(
"realloc_line: Insufficient memory" );
162 if ( startlev == NULL )
170 currlev = currlev->
next;
172 currline = currlev->
line;
188 cline = clevel->
line;
191 #ifdef CONT_PLOT_DEBUG // for 2D plots. For 3D plots look at plot3.c:plotsh3di()
193 for ( j = 1; j < cline->
npts; j++ )
202 while ( cline != NULL );
207 while ( clevel != NULL );
222 currline->
x[pts] = xx;
223 currline->
y[pts] = yy;
235 if ( currline->
npts != 0 )
238 currline = currline->
next;
268 PLFLT delta_x, delta_y;
269 PLINT currx_old, curry_old;
274 currx_old = plsc->currx;
275 curry_old = plsc->curry;
277 *distance += sqrt( delta_x * delta_x + delta_y * delta_y );
283 PLFLT scale, vec_x, vec_y, mx, my, dev_x, dev_y, off_x, off_y;
295 mx = (double) plsc->wpxscl / (
double) plsc->phyxlen;
296 my = (double) plsc->wpyscl / (
double) plsc->phyylen;
298 dev_x = -my * vec_y / mx;
299 dev_y = mx * vec_x / my;
301 scale = sqrt( ( mx * mx * dev_x * dev_x + my * my * dev_y * dev_y ) /
304 off_x = dev_x / scale;
305 off_y = dev_y / scale;
307 plptex( tpx + off_x, tpy + off_y, vec_x, vec_y, 0.5, flabel );
324 PLINT setpre, precis;
333 #define TMPSTRING_LEN 15
346 tmp = log10( value );
347 else if ( value < 0.0 )
348 tmp = log10( -value );
353 exponent = (int) tmp;
354 else if ( tmp < 0.0 )
357 if ( floor( tmp ) < tmp )
358 exponent = -(
int) ( floor( tmp ) + 1.0 );
360 exponent = -(int) ( floor( tmp ) );
363 mant = value / pow( 10.0, exponent );
366 mant = (int) ( mant * pow( 10.0, prec - 1 ) + 0.5 * mant / fabs( mant ) ) / pow( 10.0, prec - 1 );
369 snprintf(
string, (
size_t) len, form, mant );
371 strncat(
string, tmpstring, (
size_t) len - strlen(
string ) - 1 );
373 if ( abs( exponent ) <
limexp || value == 0.0 )
375 value = pow( 10.0, exponent ) * mant;
378 prec = prec - 1 - exponent;
380 prec = prec - 1 + abs( exponent );
386 snprintf(
string, (
size_t) len, form, value );
395 return ( ( x - plsc->wpxoff ) / plsc->wpxscl );
403 return ( ( y - plsc->wpyoff ) / plsc->wpyscl );
437 value = grid->
f[ix][iy];
456 value = grid->
f[ix * grid->
ny + iy];
475 value = grid->
f[ix + iy * grid->
nx];
498 plcont( f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
521 plabort(
"plcont: The pltr callback must be defined" );
526 nx, ny, kx, lx, ky, ly, clevel, nlevel,
557 if ( kx < 1 || kx >= lx )
559 plabort(
"plfcont: indices must satisfy 1 <= kx <= lx <= nx" );
562 if ( ky < 1 || ky >= ly )
564 plabort(
"plfcont: indices must satisfy 1 <= ky <= ly <= ny" );
568 if ( ( ipts = (
PLINT **) malloc( (
size_t) nx *
sizeof (
PLINT * ) ) ) == NULL )
570 plexit(
"plfcont: Insufficient memory" );
573 for ( i = 0; i < nx; i++ )
575 if ( ( ipts[i] = (
PLINT *) malloc( (
size_t) ny *
sizeof (
PLINT * ) ) ) == NULL )
577 plexit(
"plfcont: Insufficient memory" );
581 for ( i = 0; i < nlevel; i++ )
583 plcntr( f2eval, f2eval_data,
584 nx, ny, kx - 1, lx - 1, ky - 1, ly - 1, clevel[i], ipts,
595 for ( i = 0; i < nx; i++ )
597 free( (
void *) ipts[i] );
599 free( (
void *) ipts );
617 PLINT kcol, krow, lastindex;
619 PLFLT save_def, save_scale;
622 plgchr( &save_def, &save_scale );
623 save_scale = save_scale / save_def;
632 for ( kcol = kx; kcol < lx; kcol++ )
634 for ( krow = ky; krow < ly; krow++ )
636 ipts[kcol][krow] = 0;
641 for ( krow = ky; krow < ly; krow++ )
643 for ( kcol = kx; kcol < lx; kcol++ )
645 if ( ipts[kcol][krow] == 0 )
649 nx, ny, kx, lx, ky, ly, flev, flabel, kcol, krow,
650 0.0, 0.0, -2, ipts, &distance, &lastindex,
658 plschr( save_def, save_scale );
678 PLFLT px[4], py[4], locx[4], locy[4];
680 PLINT i, j, k, num, first, inext, kcolnext, krownext;
683 ( *pltr )( kcol, krow + 1, &px[0], &py[0], pltr_data );
684 ( *pltr )( kcol, krow, &px[1], &py[1], pltr_data );
685 ( *pltr )( kcol + 1, krow, &px[2], &py[2], pltr_data );
686 ( *pltr )( kcol + 1, krow + 1, &px[3], &py[3], pltr_data );
688 f[0] = f2eval( kcol, krow + 1, f2eval_data ) - flev;
689 f[1] = f2eval( kcol, krow, f2eval_data ) - flev;
690 f[2] = f2eval( kcol + 1, krow, f2eval_data ) - flev;
691 f[3] = f2eval( kcol + 1, krow + 1, f2eval_data ) - flev;
693 for ( i = 0, j = 1; i < 4; i++, j = ( j + 1 ) % 4 )
695 iedge[i] = ( f[i] * f[j] > 0.0 ) ? -1 : ( ( f[i] * f[j] < 0.0 ) ? 1 : 0 );
699 ipts[kcol][krow] = 1;
702 if ( ( iedge[0] == -1 ) && ( iedge[1] == -1 ) && ( iedge[2] == -1 )
703 && ( iedge[3] == -1 ) )
708 if ( ( f[0] == 0.0 ) && ( f[1] == 0.0 ) && ( f[2] == 0.0 ) &&
725 for ( k = 0, i = ( startedge < 0 ? 0 : startedge ); k < 4; k++, i = ( i + 1 ) % 4 )
727 if ( i == startedge )
731 if ( f[i] == 0.0 && f[( i + 1 ) % 4] == 0.0 )
743 if ( ( kcolnext < kx ) || ( kcolnext >= lx ) ||
744 ( krownext < ky ) || ( krownext >= ly ) ||
745 ( ipts[kcolnext][krownext] == 1 ) )
748 if ( ( iedge[i] == 1 ) || ( f[i] == 0.0 ) )
753 locx[num] = ( px[i] * fabs( f[j] ) + px[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
754 locy[num] = ( py[i] * fabs( f[j] ) + py[j] * fabs( f[i] ) ) / fabs( f[j] - f[i] );
782 inext = ( i + 2 ) % 4;
791 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
792 ( krownext >= ky ) && ( krownext < ly ) &&
793 ( ipts[kcolnext][krownext] == 0 ) )
796 nx, ny, kx, lx, ky, ly, flev, flabel,
798 locx[num], locy[num], inext, ipts,
811 inext = ( i + 2 ) % 4;
814 kcolnext--; krownext++;
818 krownext--; kcolnext--;
822 kcolnext++; krownext--;
826 krownext++; kcolnext++;
828 if ( ( kcolnext >= kx ) && ( kcolnext < lx ) &&
829 ( krownext >= ky ) && ( krownext < ly ) &&
830 ( ipts[kcolnext][krownext] == 0 ) )
833 nx, ny, kx, lx, ky, ly, flev, flabel,
835 locx[num], locy[num], inext, ipts,
884 PLINT ul, ur, vl, vr;
902 if ( x < 0 || x > nx - 1 || y < 0 || y > ny - 1 )
904 plexit(
"pltr1: Invalid coordinates" );
922 *tx = xl * ( 1 - du ) + xr * du;
931 *ty = yl * ( 1 - dv ) + yr * dv;
951 PLINT ul, ur, vl, vr;
953 PLFLT xll, xlr, xrl, xrr;
954 PLFLT yll, ylr, yrl, yrr;
976 if ( x < xmin || x > xmax || y < ymin || y > ymax )
978 plwarn(
"pltr2: Invalid coordinates" );
998 *tx = xll * ( 1 - dv ) + xlr * ( dv );
999 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1002 else if ( x > xmax )
1006 *tx = xg[nx - 1][0];
1007 *ty = yg[nx - 1][0];
1009 else if ( y > ymax )
1011 *tx = xg[nx - 1][ny - 1];
1012 *ty = yg[nx - 1][ny - 1];
1016 xll = xg[nx - 1][vl];
1017 yll = yg[nx - 1][vl];
1018 xlr = xg[nx - 1][vr];
1019 ylr = yg[nx - 1][vr];
1021 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1022 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1034 *tx = xll * ( 1 - du ) + xrl * ( du );
1035 *ty = yll * ( 1 - du ) + yrl * ( du );
1037 else if ( y > ymax )
1039 xlr = xg[ul][ny - 1];
1040 xrr = xg[ur][ny - 1];
1041 ylr = yg[ul][ny - 1];
1042 yrr = yg[ur][ny - 1];
1044 *tx = xlr * ( 1 - du ) + xrr * ( du );
1045 *ty = ylr * ( 1 - du ) + yrr * ( du );
1063 if ( ur == nx && vr < ny )
1068 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1069 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1074 else if ( ur < nx && vr == ny )
1079 *tx = xll * ( 1 - du ) + xrl * ( du );
1080 *ty = yll * ( 1 - du ) + yrl * ( du );
1085 else if ( ur == nx && vr == ny )
1103 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1104 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1106 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1107 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1123 PLINT ul, ur, vl, vr;
1125 PLFLT xll, xlr, xrl, xrr;
1126 PLFLT yll, ylr, yrl, yrr;
1148 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1150 plwarn(
"pltr2p: Invalid coordinates" );
1158 else if ( y > ymax )
1160 *tx = *( xg + ( ny - 1 ) );
1161 *ty = *( yg + ( ny - 1 ) );
1166 xll = *( xg + ul * ny + vl );
1167 yll = *( yg + ul * ny + vl );
1168 xlr = *( xg + ul * ny + vr );
1169 ylr = *( yg + ul * ny + vr );
1171 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1172 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1175 else if ( x > xmax )
1179 *tx = *( xg + ( ny - 1 ) * nx );
1180 *ty = *( yg + ( ny - 1 ) * nx );
1182 else if ( y > ymax )
1184 *tx = *( xg + ( ny - 1 ) + ( nx - 1 ) * ny );
1185 *ty = *( yg + ( ny - 1 ) + ( nx - 1 ) * ny );
1190 xll = *( xg + ul * ny + vl );
1191 yll = *( yg + ul * ny + vl );
1192 xlr = *( xg + ul * ny + vr );
1193 ylr = *( yg + ul * ny + vr );
1195 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1196 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1204 xll = *( xg + ul * ny + vl );
1205 xrl = *( xg + ur * ny + vl );
1206 yll = *( yg + ul * ny + vl );
1207 yrl = *( yg + ur * ny + vl );
1209 *tx = xll * ( 1 - du ) + xrl * ( du );
1210 *ty = yll * ( 1 - du ) + yrl * ( du );
1212 else if ( y > ymax )
1215 xlr = *( xg + ul * ny + vr );
1216 xrr = *( xg + ur * ny + vr );
1217 ylr = *( yg + ul * ny + vr );
1218 yrr = *( yg + ur * ny + vr );
1220 *tx = xlr * ( 1 - du ) + xrr * ( du );
1221 *ty = ylr * ( 1 - du ) + yrr * ( du );
1234 xll = *( xg + ul * ny + vl );
1235 yll = *( yg + ul * ny + vl );
1239 if ( ur == nx && vr < ny )
1241 xlr = *( xg + ul * ny + vr );
1242 ylr = *( yg + ul * ny + vr );
1244 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1245 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1250 else if ( ur < nx && vr == ny )
1252 xrl = *( xg + ur * ny + vl );
1253 yrl = *( yg + ur * ny + vl );
1255 *tx = xll * ( 1 - du ) + xrl * ( du );
1256 *ty = yll * ( 1 - du ) + yrl * ( du );
1261 else if ( ur == nx && vr == ny )
1271 xrl = *( xg + ur * ny + vl );
1272 xlr = *( xg + ul * ny + vr );
1273 xrr = *( xg + ur * ny + vr );
1275 yrl = *( yg + ur * ny + vl );
1276 ylr = *( yg + ul * ny + vr );
1277 yrr = *( yg + ur * ny + vr );
1279 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1280 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1282 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1283 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
1304 PLINT ul, ur, vl, vr;
1306 PLFLT xll, xlr, xrl, xrr;
1307 PLFLT yll, ylr, yrl, yrr;
1329 if ( x < xmin || x > xmax || y < ymin || y > ymax )
1331 plwarn(
"pltr2f: Invalid coordinates" );
1340 else if ( y > ymax )
1342 *tx = *( xg + ( ny - 1 ) * nx );
1343 *ty = *( yg + ( ny - 1 ) * nx );
1348 xll = *( xg + ul + vl * nx );
1349 yll = *( yg + ul + vl * nx );
1350 xlr = *( xg + ul + vr * nx );
1351 ylr = *( yg + ul + vr * nx );
1353 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1354 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1357 else if ( x > xmax )
1361 *tx = *( xg + ( nx - 1 ) );
1362 *ty = *( yg + ( nx - 1 ) );
1364 else if ( y > ymax )
1366 *tx = *( xg + ( nx - 1 ) + ( ny - 1 ) * nx );
1367 *ty = *( yg + ( nx - 1 ) + ( ny - 1 ) * nx );
1372 xll = *( xg + ul + vl * nx );
1373 yll = *( yg + ul + vl * nx );
1374 xlr = *( xg + ul + vr * nx );
1375 ylr = *( yg + ul + vr * nx );
1377 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1378 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1386 xll = *( xg + ul + vl * nx );
1387 xrl = *( xg + ur + vl * nx );
1388 yll = *( yg + ul + vl * nx );
1389 yrl = *( yg + ur + vl * nx );
1391 *tx = xll * ( 1 - du ) + xrl * ( du );
1392 *ty = yll * ( 1 - du ) + yrl * ( du );
1394 else if ( y > ymax )
1397 xlr = *( xg + ul + vr * nx );
1398 xrr = *( xg + ur + vr * nx );
1399 ylr = *( yg + ul + vr * nx );
1400 yrr = *( yg + ur + vr * nx );
1402 *tx = xlr * ( 1 - du ) + xrr * ( du );
1403 *ty = ylr * ( 1 - du ) + yrr * ( du );
1415 xll = *( xg + ul + vl * nx );
1416 yll = *( yg + ul + vl * nx );
1420 if ( ur == nx && vr < ny )
1422 xlr = *( xg + ul + vr * nx );
1423 ylr = *( yg + ul + vr * nx );
1425 *tx = xll * ( 1 - dv ) + xlr * ( dv );
1426 *ty = yll * ( 1 - dv ) + ylr * ( dv );
1431 else if ( ur < nx && vr == ny )
1433 xrl = *( xg + ur + vl * nx );
1434 yrl = *( yg + ur + vl * nx );
1436 *tx = xll * ( 1 - du ) + xrl * ( du );
1437 *ty = yll * ( 1 - du ) + yrl * ( du );
1442 else if ( ur == nx && vr == ny )
1452 xrl = *( xg + ur + vl * nx );
1453 xlr = *( xg + ul + vr * nx );
1454 xrr = *( xg + ur + vr * nx );
1456 yrl = *( yg + ur + vl * nx );
1457 ylr = *( yg + ul + vr * nx );
1458 yrr = *( yg + ur + vr * nx );
1459 *tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
1460 xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
1462 *ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
1463 yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );