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" );
144 if ( ( ( line->
x = (
PLFLT *) realloc( line->
x,
146 ( ( line->
y = (
PLFLT *) realloc( line->
y,
148 plexit(
"realloc_line: Insufficient memory" );
158 if ( startlev == NULL )
166 currlev = currlev->
next;
168 currline = currlev->
line;
184 cline = clevel->
line;
187 #ifdef CONT_PLOT_DEBUG // for 2D plots. For 3D plots look at plot3.c:plotsh3di()
189 for ( j = 1; j < cline->
npts; j++ )
198 while ( cline != NULL );
203 while ( clevel != NULL );
218 currline->
x[pts] = xx;
219 currline->
y[pts] = yy;
231 if ( currline->
npts != 0 )
234 currline = currline->
next;
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 );
365 snprintf(
string, (
size_t) len, form, mant );
367 strncat(
string, tmpstring, (
size_t) len - strlen(
string ) - 1 );
369 if ( abs( exponent ) <
limexp || value == 0.0 )
371 value = pow( 10.0, exponent ) * mant;
374 prec = prec - 1 - exponent;
376 prec = prec - 1 + abs( exponent );
382 snprintf(
string, (
size_t) len, form, value );
391 return ( ( x - plsc->wpxoff ) / plsc->wpxscl );
399 return ( ( y - plsc->wpyoff ) / plsc->wpyscl );
433 value = grid->
f[ix][iy];
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;
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;
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;
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;
1305 PLINT nx = cgrid->nx;
1306 PLINT ny = cgrid->ny;
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 );
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
static CONT_LEVEL * startlev
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
static PLFLT contlabel_offset
void plexit(PLCHAR_VECTOR errormsg)
static void cont_new_store(PLFLT level)
void plP_gprec(PLINT *p_setp, PLINT *p_prec)
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
void plP_movwor(PLFLT x, PLFLT y)
const PLFLT *const * PLFLT_MATRIX
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void plabort(PLCHAR_VECTOR errormsg)
static void cont_mv_store(PLFLT xx, PLFLT yy)
static double distance(point *p1, point *p2)
PLFLT(* PLF2EVAL_callback)(PLINT ix, PLINT iy, PLPointer data)
static CONT_LINE * alloc_line(void)
static CONT_LINE * currline
static PLFLT contlabel_size
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)
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 realloc_line(CONT_LINE *line)
static PLFLT contlabel_space
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)
static struct line line[]
PLFLT plf2eval1(PLINT ix, PLINT iy, PLPointer plf2eval_data)
static PLFLT plP_pcwcx(PLINT x)
static void pl_drawcontlabel(PLFLT tpx, PLFLT tpy, char *flabel, PLFLT *distance, PLINT *lastindex)
void(* PLTRANSFORM_callback)(PLFLT x, PLFLT y, PLFLT_NC_SCALAR xp, PLFLT_NC_SCALAR yp, PLPointer data)
static void cont_xy_store(PLFLT xx, PLFLT yy)
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
static PLFLT value(double n1, double n2, double hue)
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void cont_clean_store(CONT_LEVEL *ct)
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
void plP_drawor(PLFLT x, PLFLT y)
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
void plwarn(PLCHAR_VECTOR errormsg)
static CONT_LEVEL * currlev
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)
static PLFLT plP_pcwcy(PLINT y)
const PLFLT * PLFLT_VECTOR
static PLINT contlabel_active
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_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 plfloatlabel(PLFLT value, char *string, PLINT len)
static CONT_LEVEL * alloc_level(PLFLT level)