Annotation of OpenXM_contrib/gnuplot/graph3d.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: graph3d.c,v 1.106 1998/06/18 14:55:07 ddenholm Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - graph3d.c */
! 6:
! 7: /*[
! 8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 9: *
! 10: * Permission to use, copy, and distribute this software and its
! 11: * documentation for any purpose with or without fee is hereby granted,
! 12: * provided that the above copyright notice appear in all copies and
! 13: * that both that copyright notice and this permission notice appear
! 14: * in supporting documentation.
! 15: *
! 16: * Permission to modify the software is granted, but not the right to
! 17: * distribute the complete modified source code. Modifications are to
! 18: * be distributed as patches to the released version. Permission to
! 19: * distribute binaries produced by compiling modified sources is granted,
! 20: * provided you
! 21: * 1. distribute the corresponding source modifications from the
! 22: * released version in the form of a patch file along with the binaries,
! 23: * 2. add special version identification to distinguish your version
! 24: * in addition to the base release version number,
! 25: * 3. provide your name and address as the primary contact for the
! 26: * support of your modified version, and
! 27: * 4. retain our contact information in regard to use of the base
! 28: * software.
! 29: * Permission to distribute the released version of the source code along
! 30: * with corresponding source modifications in the form of a patch file is
! 31: * granted with same provisions 2 through 4 for binary distributions.
! 32: *
! 33: * This software is provided "as is" without express or implied warranty
! 34: * to the extent permitted by applicable law.
! 35: ]*/
! 36:
! 37:
! 38: /*
! 39: * AUTHORS
! 40: *
! 41: * Original Software:
! 42: * Gershon Elber and many others.
! 43: *
! 44: * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu)
! 45: * Added user-specified bases for log scaling.
! 46: *
! 47: * 3.6 - split graph3d.c into graph3d.c (graph),
! 48: * util3d.c (intersections, etc)
! 49: * hidden3d.c (hidden-line removal code)
! 50: *
! 51: */
! 52:
! 53: #include "plot.h"
! 54: #include "setshow.h"
! 55:
! 56: static int p_height;
! 57: static int p_width; /* pointsize * t->h_tic */
! 58: static int key_entry_height; /* bigger of t->v_size, pointsize*t->v_tick */
! 59:
! 60: int suppressMove = 0; /* to prevent moveto while drawing contours */
! 61:
! 62: /*
! 63: * hidden_line_type_above, hidden_line_type_below - controls type of lines
! 64: * for above and below parts of the surface.
! 65: * hidden_no_update - if TRUE lines will be hidden line removed but they
! 66: * are not assumed to be part of the surface (i.e. grid) and therefore
! 67: * do not influence the hidings.
! 68: * hidden_active - TRUE if hidden lines are to be removed.
! 69: */
! 70: int hidden_active = FALSE;
! 71: int hidden_no_update; /* HBB 980324: made this visible despite LITE */
! 72:
! 73: /* LITE defines a restricted memory version for MS-DOS, which doesn't
! 74: * use the routines in hidden3d.c
! 75: */
! 76:
! 77: #ifndef LITE
! 78: int hidden_line_type_above, hidden_line_type_below;
! 79: #endif /* LITE */
! 80:
! 81:
! 82: static double LogScale __PROTO((double coord, TBOOLEAN is_log,
! 83: double log_base_log, char *what, char *axis));
! 84: static void plot3d_impulses __PROTO((struct surface_points * plot));
! 85: static void plot3d_lines __PROTO((struct surface_points * plot));
! 86: static void plot3d_points __PROTO((struct surface_points * plot));
! 87: static void plot3d_dots __PROTO((struct surface_points * plot));
! 88: static void cntr3d_impulses __PROTO((struct gnuplot_contours * cntr,
! 89: struct surface_points * plot));
! 90: static void cntr3d_lines __PROTO((struct gnuplot_contours * cntr));
! 91: static void cntr3d_points __PROTO((struct gnuplot_contours * cntr,
! 92: struct surface_points * plot));
! 93: static void cntr3d_dots __PROTO((struct gnuplot_contours * cntr));
! 94: static void check_corner_height __PROTO((struct coordinate GPHUGE * point,
! 95: double height[2][2], double depth[2][2]));
! 96: static void draw_bottom_grid __PROTO((struct surface_points * plot,
! 97: int plot_count));
! 98: static void xtick_callback __PROTO((int axis, double place, char *text,
! 99: struct lp_style_type grid));
! 100: static void ytick_callback __PROTO((int axis, double place, char *text,
! 101: struct lp_style_type grid));
! 102: static void ztick_callback __PROTO((int axis, double place, char *text,
! 103: struct lp_style_type grid));
! 104: static void setlinestyle __PROTO((struct lp_style_type style));
! 105:
! 106: static void boundary3d __PROTO((int scaling, struct surface_points * plots,
! 107: int count));
! 108: #if 0 /* not used */
! 109: static double dbl_raise __PROTO((double x, int y));
! 110: #endif
! 111: static void map_position __PROTO((struct position * pos, unsigned int *x,
! 112: unsigned int *y, char *what));
! 113:
! 114: /* put entries in the key */
! 115: static void key_sample_line __PROTO((int xl, int yl));
! 116: static void key_sample_point __PROTO((int xl, int yl, int pointtype));
! 117: static void key_text __PROTO((int xl, int yl, char *text));
! 118:
! 119:
! 120: #if defined(sun386) || defined(AMIGA_SC_6_1)
! 121: static double CheckLog __PROTO((TBOOLEAN is_log, double base_log, double x));
! 122: #endif
! 123:
! 124: /*
! 125: * The Amiga SAS/C 6.2 compiler moans about macro envocations causing
! 126: * multiple calls to functions. I converted these macros to inline
! 127: * functions coping with the problem without loosing speed.
! 128: * (MGR, 1993)
! 129: */
! 130: #ifdef AMIGA_SC_6_1
! 131: GP_INLINE static TBOOLEAN i_inrange(int z, int min, int max)
! 132: {
! 133: return ((min < max) ? ((z >= min) && (z <= max)) : ((z >= max) && (z <= min)));
! 134: }
! 135:
! 136: GP_INLINE static double f_max(double a, double b)
! 137: {
! 138: return (max(a, b));
! 139: }
! 140:
! 141: GP_INLINE static double f_min(double a, double b)
! 142: {
! 143: return (min(a, b));
! 144: }
! 145:
! 146: #else
! 147: # define f_max(a,b) GPMAX((a),(b))
! 148: # define f_min(a,b) GPMIN((a),(b))
! 149: # define i_inrange(z,a,b) inrange((z),(a),(b))
! 150: #endif
! 151:
! 152: #define apx_eq(x,y) (fabs(x-y) < 0.001)
! 153: #define ABS(x) ((x) >= 0 ? (x) : -(x))
! 154: #define SQR(x) ((x) * (x))
! 155:
! 156: /* Define the boundary of the plot
! 157: * These are computed at each call to do_plot, and are constant over
! 158: * the period of one do_plot. They actually only change when the term
! 159: * type changes and when the 'set size' factors change.
! 160: */
! 161:
! 162: /* in order to allow graphic.c to use clip_draw_line, we must
! 163: * share xleft, xright, ybot, ytop with graphics.c
! 164: */
! 165: extern int xleft, xright, ybot, ytop;
! 166:
! 167: int xmiddle, ymiddle, xscaler, yscaler;
! 168: static int ptitl_cnt;
! 169: static int max_ptitl_len;
! 170: static int titlelin;
! 171: static int key_sample_width, key_rows, key_cols, key_col_wth, yl_ref;
! 172: static int ktitle_lines = 0;
! 173:
! 174:
! 175: /* Boundary and scale factors, in user coordinates */
! 176: /* x_min3d, x_max3d, y_min3d, y_max3d, z_min3d, z_max3d are local to this
! 177: * file and are not the same as variables of the same names in other files
! 178: */
! 179: /*static double x_min3d, x_max3d, y_min3d, y_max3d, z_min3d, z_max3d; */
! 180: /* sizes are now set in min_array[], max_array[] from plot.c */
! 181: extern double min_array[], max_array[];
! 182: extern int auto_array[], log_array[];
! 183: extern double base_array[], log_base_array[];
! 184:
! 185: /* for convenience while converting to use these arrays */
! 186: #define x_min3d min_array[FIRST_X_AXIS]
! 187: #define x_max3d max_array[FIRST_X_AXIS]
! 188: #define y_min3d min_array[FIRST_Y_AXIS]
! 189: #define y_max3d max_array[FIRST_Y_AXIS]
! 190: #define z_min3d min_array[FIRST_Z_AXIS]
! 191: #define z_max3d max_array[FIRST_Z_AXIS]
! 192:
! 193: /* There are several z's to take into account - I hope I get these
! 194: * right !
! 195: *
! 196: * ceiling_z is the highest z in use
! 197: * floor_z is the lowest z in use
! 198: * base_z is the z of the base
! 199: * min3d_z is the lowest z of the graph area
! 200: * max3d_z is the highest z of the graph area
! 201: *
! 202: * ceiling_z is either max3d_z or base_z, and similarly for floor_z
! 203: * There should be no part of graph drawn outside
! 204: * min3d_z:max3d_z - apart from arrows, perhaps
! 205: */
! 206:
! 207: double ceiling_z, floor_z, base_z;
! 208:
! 209: /* and some bodges while making the change */
! 210: #define min3d_z min_array[FIRST_Z_AXIS]
! 211: #define max3d_z max_array[FIRST_Z_AXIS]
! 212:
! 213:
! 214: double xscale3d, yscale3d, zscale3d;
! 215:
! 216:
! 217: typedef double transform_matrix[4][4];
! 218: transform_matrix trans_mat;
! 219:
! 220: static double xaxis_y, yaxis_x, zaxis_x, zaxis_y;
! 221:
! 222: /* the co-ordinates of the back corner */
! 223: static double back_x, back_y;
! 224:
! 225: /* the penalty for convenience of using tic_gen to make callbacks
! 226: * to tick routines is that we cant pass parameters very easily.
! 227: * We communicate with the tick_callbacks using static variables
! 228: */
! 229:
! 230: /* unit vector (terminal coords) */
! 231: static double tic_unitx, tic_unity;
! 232:
! 233: /* (DFK) Watch for cancellation error near zero on axes labels */
! 234: #define SIGNIF (0.01) /* less than one hundredth of a tic mark */
! 235: #define CheckZero(x,tic) (fabs(x) < ((tic) * SIGNIF) ? 0.0 : (x))
! 236: #define NearlyEqual(x,y,tic) (fabs((x)-(y)) < ((tic) * SIGNIF))
! 237:
! 238: /* And the functions to map from user to terminal coordinates */
! 239: #define map_x(x) (int)(x+0.5) /* maps floating point x to screen */
! 240: #define map_y(y) (int)(y+0.5) /* same for y */
! 241:
! 242: /* And the functions to map from user 3D space into normalized -1..1 */
! 243: #define map_x3d(x) ((x-x_min3d)*xscale3d-1.0)
! 244: #define map_y3d(y) ((y-y_min3d)*yscale3d-1.0)
! 245: #define map_z3d(z) ((z-floor_z)*zscale3d-1.0)
! 246:
! 247:
! 248:
! 249: /* Initialize the line style using the current device and set hidden styles
! 250: * to it as well if hidden line removal is enabled */
! 251: static void setlinestyle(style)
! 252: struct lp_style_type style;
! 253: {
! 254: term_apply_lp_properties(&style);
! 255:
! 256: #ifndef LITE
! 257: if (hidden3d) {
! 258: hidden_line_type_above = style.l_type;
! 259: hidden_line_type_below = style.l_type;
! 260: }
! 261: #endif /* LITE */
! 262: }
! 263:
! 264: /* (DFK) For some reason, the Sun386i compiler screws up with the CheckLog
! 265: * macro, so I write it as a function on that machine.
! 266: *
! 267: * Amiga SAS/C 6.2 thinks it will do too much work calling functions in
! 268: * macro arguments twice, thus I inline theese functions. (MGR, 1993)
! 269: */
! 270: #if defined(sun386) || defined(AMIGA_SC_6_1)
! 271: GP_INLINE static double CheckLog(is_log, base_log, x)
! 272: TBOOLEAN is_log;
! 273: double base_log;
! 274: double x;
! 275: {
! 276: if (is_log)
! 277: return (pow(base_log, x));
! 278: else
! 279: return (x);
! 280: }
! 281: #else
! 282: /* (DFK) Use 10^x if logscale is in effect, else x */
! 283: # define CheckLog(is_log, base_log, x) ((is_log) ? pow(base_log, (x)) : (x))
! 284: #endif /* sun386 || SAS/C */
! 285:
! 286: static double LogScale(coord, is_log, log_base_log, what, axis)
! 287: double coord; /* the value */
! 288: TBOOLEAN is_log; /* is this axis in logscale? */
! 289: double log_base_log; /* if so, the log of its base */
! 290: char *what; /* what is the coord for? */
! 291: char *axis; /* which axis is this for ("x" or "y")? */
! 292: {
! 293: if (is_log) {
! 294: if (coord <= 0.0) {
! 295: char errbuf[100]; /* place to write error message */
! 296: (void) sprintf(errbuf, "%s has %s coord of %g; must be above 0 for log scale!",
! 297: what, axis, coord);
! 298: graph_error(errbuf);
! 299: } else
! 300: return (log(coord) / log_base_log);
! 301: }
! 302: return (coord);
! 303: }
! 304:
! 305: /* And the functions to map from user 3D space to terminal coordinates */
! 306: void map3d_xy(x, y, z, xt, yt)
! 307: double x, y, z;
! 308: unsigned int *xt, *yt;
! 309: {
! 310: int i, j;
! 311: double v[4], res[4], /* Homogeneous coords. vectors. */
! 312: w = trans_mat[3][3];
! 313:
! 314: v[0] = map_x3d(x); /* Normalize object space to -1..1 */
! 315: v[1] = map_y3d(y);
! 316: v[2] = map_z3d(z);
! 317: v[3] = 1.0;
! 318:
! 319: for (i = 0; i < 2; i++) { /* Dont use the third axes (z). */
! 320: res[i] = trans_mat[3][i]; /* Initiate it with the weight factor */
! 321: for (j = 0; j < 3; j++)
! 322: res[i] += v[j] * trans_mat[j][i];
! 323: }
! 324:
! 325: for (i = 0; i < 3; i++)
! 326: w += v[i] * trans_mat[i][3];
! 327: if (w == 0)
! 328: w = 1e-5;
! 329:
! 330: *xt = (unsigned int) ((res[0] * xscaler / w) + xmiddle);
! 331: *yt = (unsigned int) ((res[1] * yscaler / w) + ymiddle);
! 332: }
! 333:
! 334:
! 335:
! 336: /* And the functions to map from user 3D space to terminal z coordinate */
! 337: int map3d_z(x, y, z)
! 338: double x, y, z;
! 339: {
! 340: int i, zt;
! 341: double v[4], res, /* Homogeneous coords. vectors. */
! 342: w = trans_mat[3][3];
! 343:
! 344: v[0] = map_x3d(x); /* Normalize object space to -1..1 */
! 345: v[1] = map_y3d(y);
! 346: v[2] = map_z3d(z);
! 347: v[3] = 1.0;
! 348:
! 349: res = trans_mat[3][2]; /* Initiate it with the weight factor. */
! 350: for (i = 0; i < 3; i++)
! 351: res += v[i] * trans_mat[i][2];
! 352: if (w == 0)
! 353: w = 1e-5;
! 354: for (i = 0; i < 3; i++)
! 355: w += v[i] * trans_mat[i][3];
! 356: zt = ((int) (res * 16384 / w));
! 357: return zt;
! 358: }
! 359:
! 360: /* borders of plotting area */
! 361: /* computed once on every call to do_plot */
! 362: static void boundary3d(scaling, plots, count)
! 363: TBOOLEAN scaling; /* TRUE if terminal is doing the scaling */
! 364: struct surface_points *plots;
! 365: int count;
! 366: {
! 367: register struct termentry *t = term;
! 368: int ytlen, i;
! 369:
! 370: titlelin = 0;
! 371:
! 372: p_height = pointsize * t->v_tic;
! 373: p_width = pointsize * t->h_tic;
! 374: if (key_swidth >= 0)
! 375: key_sample_width = key_swidth * (t->h_char) + pointsize * (t->h_tic);
! 376: else
! 377: key_sample_width = 0;
! 378: key_entry_height = pointsize * (t->v_tic) * 1.25 * key_vert_factor;
! 379: if (key_entry_height < (t->v_char)) {
! 380: /* is this reasonable ? */
! 381: key_entry_height = (t->v_char) * key_vert_factor;
! 382: }
! 383:
! 384: /* count max_len key and number keys (plot-titles and contour labels) with len > 0 */
! 385: max_ptitl_len = find_maxl_keys3d(plots, count, &ptitl_cnt);
! 386: if ((ytlen = label_width(key_title, &ktitle_lines)) > max_ptitl_len)
! 387: max_ptitl_len = ytlen;
! 388: key_col_wth = (max_ptitl_len + 4) * (t->h_char) + key_sample_width;
! 389:
! 390: /* luecken@udel.edu modifications
! 391: sizes the plot to take up more of available resolution */
! 392: if (lmargin >= 0)
! 393: xleft = (t->h_char) * lmargin;
! 394: else
! 395: xleft = (t->h_char) * 2 + (t->h_tic);
! 396: xright = (scaling ? 1 : xsize) * (t->xmax) - (t->h_char) * 2 - (t->h_tic);
! 397: key_rows = ptitl_cnt;
! 398: key_cols = 1;
! 399: if (key == -1 && key_vpos == TUNDER) {
! 400: /* calculate max no cols, limited by label-length */
! 401: key_cols = (int) (xright - xleft) / ((max_ptitl_len + 4) * (t->h_char) + key_sample_width);
! 402: key_rows = (int) (ptitl_cnt / key_cols) + ((ptitl_cnt % key_cols) > 0);
! 403: /* now calculate actual no cols depending on no rows */
! 404: key_cols = (int) (ptitl_cnt / key_rows) + ((ptitl_cnt % key_rows) > 0);
! 405: key_col_wth = (int) (xright - xleft) / key_cols;
! 406: /* key_rows += ktitle_lines; - messes up key - div */
! 407: }
! 408: /* this should also consider the view and number of lines in
! 409: * xformat || yformat || xlabel || ylabel */
! 410:
! 411: /* an absolute 1, with no terminal-dependent scaling ? */
! 412: ybot = (t->v_char) * 2.5 + 1;
! 413: if (key_rows && key_vpos == TUNDER)
! 414: ybot += key_rows * key_entry_height + ktitle_lines * t->v_char;
! 415:
! 416: if (strlen(title.text)) {
! 417: titlelin++;
! 418: for (i = 0; i < strlen(title.text); i++) {
! 419: if (title.text[i] == '\\')
! 420: titlelin++;
! 421: }
! 422: }
! 423: ytop = (scaling ? 1 : ysize) * (t->ymax) - (t->v_char) * (titlelin + 1.5) - 1;
! 424: if (key == -1 && key_vpos != TUNDER) {
! 425: /* calculate max no rows, limited be ytop-ybot */
! 426: i = (int) (ytop - ybot) / (t->v_char) - 1 - ktitle_lines;
! 427: if (ptitl_cnt > i) {
! 428: key_cols = (int) (ptitl_cnt / i) + ((ptitl_cnt % i) > 0);
! 429: /* now calculate actual no rows depending on no cols */
! 430: key_rows = (int) (ptitl_cnt / key_cols) + ((ptitl_cnt % key_cols) > 0);
! 431: }
! 432: key_rows += ktitle_lines;
! 433: }
! 434: if (key_hpos == TOUT) {
! 435: xright -= key_col_wth * (key_cols - 1) + key_col_wth - 2 * (t->h_char);
! 436: }
! 437: xleft += t->xmax * xoffset;
! 438: xright += t->xmax * xoffset;
! 439: ytop += t->ymax * yoffset;
! 440: ybot += t->ymax * yoffset;
! 441: xmiddle = (xright + xleft) / 2;
! 442: ymiddle = (ytop + ybot) / 2;
! 443: /* HBB 980308: sigh... another 16bit glitch: on term's with more than
! 444: * 8000 pixels in either direction, these calculations produce garbage
! 445: * results if done in (16bit) ints */
! 446: xscaler = (xright - xleft) * 4 / 7; /* HBB: Magic number alert! */
! 447: yscaler = ((ytop - ybot) * 4L) / 7L;
! 448:
! 449: }
! 450:
! 451: #if 0
! 452: /* not used ; anyway, should be done using bitshifts and squares,
! 453: * rather than iteratively
! 454: */
! 455: static double dbl_raise(x, y)
! 456: double x;
! 457: int y;
! 458: {
! 459: register int i = ABS(y);
! 460: double val = 1.0;
! 461: while (--i >= 0)
! 462: val *= x;
! 463: if (y < 0)
! 464: return (1.0 / val);
! 465: return (val);
! 466: }
! 467: #endif
! 468:
! 469: /* we precalculate features of the key, to save lots of nested
! 470: * ifs in code - x,y = user supplied or computed position of key
! 471: * taken to be inner edge of a line sample
! 472: */
! 473: static int key_sample_left; /* offset from x for left of line sample */
! 474: static int key_sample_right; /* offset from x for right of line sample */
! 475: static int key_point_offset; /* offset from x for point sample */
! 476: static int key_text_left; /* offset from x for left-justified text */
! 477: static int key_text_right; /* offset from x for right-justified text */
! 478: static int key_size_left; /* distance from x to left edge of box */
! 479: static int key_size_right; /* distance from x to right edge of box */
! 480:
! 481: void do_3dplot(plots, pcount)
! 482: struct surface_points *plots;
! 483: int pcount; /* count of plots in linked list */
! 484: {
! 485: struct termentry *t = term;
! 486: int surface;
! 487: struct surface_points *this_plot = NULL;
! 488: unsigned int xl, yl;
! 489: int linetypeOffset = 0;
! 490: double ztemp, temp;
! 491: struct text_label *this_label;
! 492: struct arrow_def *this_arrow;
! 493: TBOOLEAN scaling;
! 494: transform_matrix mat;
! 495: int key_count;
! 496: char ss[MAX_LINE_LEN+1], *s, *e;
! 497:
! 498: /* Initiate transformation matrix using the global view variables. */
! 499: mat_rot_z(surface_rot_z, trans_mat);
! 500: mat_rot_x(surface_rot_x, mat);
! 501: mat_mult(trans_mat, trans_mat, mat);
! 502: mat_scale(surface_scale / 2.0, surface_scale / 2.0, surface_scale / 2.0, mat);
! 503: mat_mult(trans_mat, trans_mat, mat);
! 504:
! 505: /* modify min_z/max_z so it will zscale properly. */
! 506: ztemp = (z_max3d - z_min3d) / (2.0 * surface_zscale);
! 507: temp = (z_max3d + z_min3d) / 2.0;
! 508: z_min3d = temp - ztemp;
! 509: z_max3d = temp + ztemp;
! 510:
! 511:
! 512: /* The extrema need to be set even when a surface is not being
! 513: * drawn. Without this, gnuplot used to assume that the X and
! 514: * Y axis started at zero. -RKC
! 515: */
! 516:
! 517: if (polar)
! 518: graph_error("Cannot splot in polar coordinate system.");
! 519:
! 520: /* done in plot3d.c
! 521: * if (z_min3d == VERYLARGE || z_max3d == -VERYLARGE ||
! 522: * x_min3d == VERYLARGE || x_max3d == -VERYLARGE ||
! 523: * y_min3d == VERYLARGE || y_max3d == -VERYLARGE)
! 524: * graph_error("all points undefined!");
! 525: */
! 526:
! 527: /* If we are to draw the bottom grid make sure zmin is updated properly. */
! 528: if (xtics || ytics || work_grid.l_type) {
! 529: base_z = z_min3d - (z_max3d - z_min3d) * ticslevel;
! 530: if (ticslevel >= 0)
! 531: floor_z = base_z;
! 532: else
! 533: floor_z = z_min3d;
! 534:
! 535: if (ticslevel < -1)
! 536: ceiling_z = base_z;
! 537: else
! 538: ceiling_z = z_max3d;
! 539: } else {
! 540: floor_z = base_z = z_min3d;
! 541: ceiling_z = z_max3d;
! 542: }
! 543:
! 544: /* see comment accompanying similar tests of x_min/x_max and y_min/y_max
! 545: * in graphics.c:do_plot(), for history/rationale of these tests */
! 546: if (x_min3d == x_max3d)
! 547: graph_error("x_min3d should not equal x_max3d!");
! 548: if (y_min3d == y_max3d)
! 549: graph_error("y_min3d should not equal y_max3d!");
! 550: if (z_min3d == z_max3d)
! 551: graph_error("z_min3d should not equal z_max3d!");
! 552:
! 553: #ifndef LITE
! 554: if (hidden3d) {
! 555: struct surface_points *plot;
! 556: int p = 0;
! 557: /* Verify data is hidden line removable - grid based. */
! 558: for (plot = plots; ++p <= pcount; plot = plot->next_sp) {
! 559: if (plot->plot_type == DATA3D && !plot->has_grid_topology) {
! 560: fprintf(stderr, "Notice: Cannot remove hidden lines from non grid data\n");
! 561: return;
! 562: }
! 563: }
! 564: }
! 565: #endif /* not LITE */
! 566:
! 567: term_start_plot();
! 568:
! 569: screen_ok = FALSE;
! 570: scaling = (*t->scale) (xsize, ysize);
! 571:
! 572: /* now compute boundary for plot (xleft, xright, ytop, ybot) */
! 573: boundary3d(scaling, plots, pcount);
! 574:
! 575: /* SCALE FACTORS */
! 576: zscale3d = 2.0 / (ceiling_z - floor_z);
! 577: yscale3d = 2.0 / (y_max3d - y_min3d);
! 578: xscale3d = 2.0 / (x_max3d - x_min3d);
! 579:
! 580: term_apply_lp_properties(&border_lp); /* border linetype */
! 581:
! 582: /* PLACE TITLE */
! 583: if (*title.text != 0) {
! 584: safe_strncpy(ss, title.text, sizeof(ss));
! 585: write_multiline((unsigned int) ((xleft + xright) / 2 + title.xoffset * t->h_char),
! 586: (unsigned int) (ytop + (titlelin + title.yoffset) * (t->h_char)),
! 587: ss, CENTRE, JUST_TOP, 0, title.font);
! 588: }
! 589: /* PLACE TIMEDATE */
! 590: if (*timelabel.text) {
! 591: char str[MAX_LINE_LEN+1];
! 592: time_t now;
! 593: unsigned int x = t->v_char + timelabel.xoffset * t->h_char;
! 594: unsigned int y = timelabel_bottom ?
! 595: yoffset * ymax + (timelabel.yoffset + 1) * t->v_char :
! 596: ytop + (timelabel.yoffset - 1) * t->v_char;
! 597:
! 598: time(&now);
! 599: strftime(str, MAX_LINE_LEN, timelabel.text, localtime(&now));
! 600:
! 601: if (timelabel_rotate && (*t->text_angle) (1)) {
! 602: if (timelabel_bottom)
! 603: write_multiline(x, y, str, LEFT, JUST_TOP, 1, timelabel.font);
! 604: else
! 605: write_multiline(x, y, str, RIGHT, JUST_TOP, 1, timelabel.font);
! 606:
! 607: (*t->text_angle) (0);
! 608: } else {
! 609: if (timelabel_bottom)
! 610: write_multiline(x, y, str, LEFT, JUST_BOT, 0, timelabel.font);
! 611: else
! 612: write_multiline(x, y, str, LEFT, JUST_TOP, 0, timelabel.font);
! 613: }
! 614: }
! 615: /* PLACE LABELS */
! 616: for (this_label = first_label; this_label != NULL;
! 617: this_label = this_label->next) {
! 618: unsigned int x, y;
! 619:
! 620:
! 621: map_position(&this_label->place, &x, &y, "label");
! 622: safe_strncpy(ss, this_label->text, sizeof(ss));
! 623: if (this_label->rotate && (*t->text_angle) (1)) {
! 624: write_multiline(x, y, this_label->text, this_label->pos, CENTRE, 1, this_label->font);
! 625: (*t->text_angle) (0);
! 626: } else {
! 627: write_multiline(x, y, this_label->text, this_label->pos, CENTRE, 0, this_label->font);
! 628: }
! 629: }
! 630:
! 631: /* PLACE ARROWS */
! 632: for (this_arrow = first_arrow; this_arrow != NULL;
! 633: this_arrow = this_arrow->next) {
! 634: unsigned int sx, sy, ex, ey;
! 635:
! 636: map_position(&this_arrow->start, &sx, &sy, "arrow");
! 637: map_position(&this_arrow->end, &ex, &ey, "arrow");
! 638: term_apply_lp_properties(&(this_arrow->lp_properties));
! 639: (*t->arrow) (sx, sy, ex, ey, this_arrow->head);
! 640: }
! 641:
! 642: #ifndef LITE
! 643: if (hidden3d && draw_surface) {
! 644: init_hidden_line_removal();
! 645: reset_hidden_line_removal();
! 646: hidden_active = TRUE;
! 647: }
! 648: #endif /* not LITE */
! 649:
! 650: /* WORK OUT KEY SETTINGS AND DO KEY TITLE / BOX */
! 651:
! 652: if (key_reverse) {
! 653: key_sample_left = -key_sample_width;
! 654: key_sample_right = 0;
! 655: key_text_left = t->h_char;
! 656: key_text_right = (t->h_char) * (max_ptitl_len + 1);
! 657: key_size_right = (t->h_char) * (max_ptitl_len + 2 + key_width_fix);
! 658: key_size_left = (t->h_char) + key_sample_width;
! 659: } else {
! 660: key_sample_left = 0;
! 661: key_sample_right = key_sample_width;
! 662: key_text_left = -(int) ((t->h_char) * (max_ptitl_len + 1));
! 663: key_text_right = -(int) (t->h_char);
! 664: key_size_left = (t->h_char) * (max_ptitl_len + 2 + key_width_fix);
! 665: key_size_right = (t->h_char) + key_sample_width;
! 666: }
! 667: key_point_offset = (key_sample_left + key_sample_right) / 2;
! 668:
! 669: if (key == -1) {
! 670: if (key_vpos == TUNDER) {
! 671: #if 0
! 672: yl = yoffset * t->ymax + (key_rows) * key_entry_height + (ktitle_lines + 2) * t->v_char;
! 673: xl = max_ptitl_len * 1000 / (key_sample_width / (t->h_char) + max_ptitl_len + 2);
! 674: xl *= (xright - xleft) / key_cols;
! 675: xl /= 1000;
! 676: xl += xleft;
! 677: #else
! 678: /* maximise no cols, limited by label-length */
! 679: key_cols = (int) (xright - xleft) / key_col_wth;
! 680: key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
! 681: /* now calculate actual no cols depending on no rows */
! 682: key_cols = (int) (ptitl_cnt + key_rows - 1) / key_rows;
! 683: key_col_wth = (int) (xright - xleft) / key_cols;
! 684: /* we divide into columns, then centre in column by considering
! 685: * ratio of key_left_size to key_right_size
! 686: * key_size_left/(key_size_left+key_size_right) * (xright-xleft)/key_cols
! 687: * do one integer division to maximise accuracy (hope we dont
! 688: * overflow !)
! 689: */
! 690: xl = xleft + ((xright - xleft) * key_size_left) / (key_cols * (key_size_left + key_size_right));
! 691: yl = yoffset * t->ymax + (key_rows) * key_entry_height + (ktitle_lines + 2) * t->v_char;
! 692: #endif
! 693: } else {
! 694: if (key_vpos == TTOP) {
! 695: yl = ytop - (t->v_tic) - t->v_char;
! 696: } else {
! 697: yl = ybot + (t->v_tic) + key_entry_height * key_rows + ktitle_lines * t->v_char;
! 698: }
! 699: if (key_hpos == TOUT) {
! 700: /* keys outside plot border (right) */
! 701: xl = xright + (t->h_tic) + key_size_left;
! 702: } else if (key_hpos == TLEFT) {
! 703: xl = xleft + (t->h_tic) + key_size_left;
! 704: } else {
! 705: xl = xright - key_size_right - key_col_wth * (key_cols - 1);
! 706: }
! 707: }
! 708: yl_ref = yl - ktitle_lines * (t->v_char);
! 709: }
! 710: if (key == 1) {
! 711: map_position(&key_user_pos, &xl, &yl, "key");
! 712: }
! 713: if (key && key_box.l_type > -3) {
! 714: int yt = yl;
! 715: int yb = yl - key_entry_height * (key_rows - ktitle_lines) - ktitle_lines * t->v_char;
! 716: int key_xr = xl + key_col_wth * (key_cols - 1) + key_size_right;
! 717: /* key_rows seems to contain title at this point ??? */
! 718: term_apply_lp_properties(&key_box);
! 719: (*t->move) (xl - key_size_left, yb);
! 720: (*t->vector) (xl - key_size_left, yt);
! 721: (*t->vector) (key_xr, yt);
! 722: (*t->vector) (key_xr, yb);
! 723: (*t->vector) (xl - key_size_left, yb);
! 724:
! 725: /* draw a horizontal line between key title and first entry JFi */
! 726: (*t->move) (xl - key_size_left, yt - (ktitle_lines) * t->v_char);
! 727: (*t->vector) (xl + key_size_right, yt - (ktitle_lines) * t->v_char);
! 728: }
! 729: /* DRAW SURFACES AND CONTOURS */
! 730:
! 731: #ifndef LITE
! 732: if (hidden3d && draw_surface)
! 733: plot3d_hidden(plots, pcount);
! 734: #endif /* not LITE */
! 735:
! 736: /* KEY TITLE */
! 737: if (key != 0 && strlen(key_title)) {
! 738: sprintf(ss, "%s\n", key_title);
! 739: s = ss;
! 740: yl -= t->v_char / 2;
! 741: while ((e = (char *) strchr(s, '\n')) != NULL) {
! 742: *e = '\0';
! 743: if (key_just == JLEFT) {
! 744: (*t->justify_text) (LEFT);
! 745: (*t->put_text) (xl + key_text_left, yl, s);
! 746: } else {
! 747: if ((*t->justify_text) (RIGHT)) {
! 748: (*t->put_text) (xl + key_text_right,
! 749: yl, s);
! 750: } else {
! 751: int x = xl + key_text_right - (t->h_char) * strlen(s);
! 752: if (inrange(x, xleft, xright))
! 753: (*t->put_text) (x, yl, s);
! 754: }
! 755: }
! 756: s = ++e;
! 757: yl -= t->v_char;
! 758: }
! 759: yl += t->v_char / 2;
! 760: }
! 761: key_count = 0;
! 762: yl_ref = yl -= key_entry_height / 2; /* centralise the keys */
! 763:
! 764: #define NEXT_KEY_LINE() \
! 765: if ( ++key_count >= key_rows ) { \
! 766: yl = yl_ref; xl += key_col_wth; key_count = 0; \
! 767: } else \
! 768: yl -= key_entry_height
! 769:
! 770: this_plot = plots;
! 771: for (surface = 0;
! 772: surface < pcount;
! 773: this_plot = this_plot->next_sp, surface++) {
! 774:
! 775: #ifndef LITE
! 776: if (hidden3d)
! 777: hidden_no_update = FALSE;
! 778: #endif /* not LITE */
! 779:
! 780: if (draw_surface) {
! 781: int lkey = (key != 0 && this_plot->title && this_plot->title[0]);
! 782: term_apply_lp_properties(&(this_plot->lp_properties));
! 783:
! 784: #ifndef LITE
! 785: if (hidden3d) {
! 786: hidden_line_type_above = this_plot->lp_properties.l_type;
! 787: hidden_line_type_below = this_plot->lp_properties.l_type + 1;
! 788: }
! 789: #endif /* not LITE */
! 790:
! 791: if (lkey) {
! 792: key_text(xl, yl, this_plot->title);
! 793: }
! 794: switch (this_plot->plot_style) {
! 795: case BOXES: /* can't do boxes in 3d yet so use impulses */
! 796: case IMPULSES:{
! 797: if (lkey) {
! 798: key_sample_line(xl, yl);
! 799: }
! 800: if (!(hidden3d && draw_surface))
! 801: plot3d_impulses(this_plot);
! 802: break;
! 803: }
! 804: case STEPS: /* HBB: I think these should be here */
! 805: case FSTEPS:
! 806: case HISTEPS:
! 807: case LINES:{
! 808: if (lkey) {
! 809: key_sample_line(xl, yl);
! 810: }
! 811: if (!(hidden3d && draw_surface))
! 812: plot3d_lines(this_plot);
! 813: break;
! 814: }
! 815: case YERRORBARS: /* ignored; treat like points */
! 816: case XERRORBARS: /* ignored; treat like points */
! 817: case XYERRORBARS: /* ignored; treat like points */
! 818: case BOXXYERROR: /* HBB: ignore these as well */
! 819: case BOXERROR:
! 820: case CANDLESTICKS: /* HBB: dito */
! 821: case FINANCEBARS:
! 822: case VECTOR:
! 823: case POINTSTYLE:
! 824: if (lkey && !clip_point(xl + key_point_offset, yl)) {
! 825: key_sample_point(xl, yl, this_plot->lp_properties.p_type);
! 826: }
! 827: if (!(hidden3d && draw_surface))
! 828: plot3d_points(this_plot);
! 829: break;
! 830:
! 831: case LINESPOINTS:
! 832: /* put lines */
! 833: if (lkey)
! 834: key_sample_line(xl, yl);
! 835:
! 836: if (!(hidden3d && draw_surface))
! 837: plot3d_lines(this_plot);
! 838:
! 839: /* put points */
! 840: if (lkey && !clip_point(xl + key_point_offset, yl))
! 841: key_sample_point(xl, yl, this_plot->lp_properties.p_type);
! 842:
! 843: if (!(hidden3d && draw_surface))
! 844: plot3d_points(this_plot);
! 845:
! 846: break;
! 847:
! 848: case DOTS:
! 849: if (lkey) {
! 850: if (key == 1) {
! 851: if (!clip_point(xl + key_point_offset, yl))
! 852: (*t->point) (xl + key_point_offset, yl, -1);
! 853: } else {
! 854: (*t->point) (xl + key_point_offset, yl, -1);
! 855: /* (*t->point)(xl+2*(t->h_char),yl, -1); */
! 856: }
! 857: }
! 858: if (!(hidden3d && draw_surface))
! 859: plot3d_dots(this_plot);
! 860:
! 861: break;
! 862:
! 863:
! 864: } /* switch(plot-style) */
! 865:
! 866: /* move key on a line */
! 867: if (lkey) {
! 868: NEXT_KEY_LINE();
! 869: }
! 870: } /* draw_surface */
! 871:
! 872: #ifndef LITE
! 873: if (hidden3d) {
! 874: hidden_no_update = TRUE;
! 875: hidden_line_type_above = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
! 876: hidden_line_type_below = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
! 877: }
! 878: #endif /* not LITE */
! 879:
! 880: if (draw_contour && this_plot->contours != NULL) {
! 881: struct gnuplot_contours *cntrs = this_plot->contours;
! 882:
! 883: term_apply_lp_properties(&(this_plot->lp_properties));
! 884: (*t->linetype) (this_plot->lp_properties.l_type + (hidden3d ? 2 : 1));
! 885:
! 886: if (key != 0 && this_plot->title && this_plot->title[0]
! 887: && !draw_surface && !label_contours) {
! 888: /* unlabelled contours but no surface : put key entry in now */
! 889: key_text(xl, yl, this_plot->title);
! 890:
! 891: switch (this_plot->plot_style) {
! 892: case IMPULSES:
! 893: case LINES:
! 894: case BOXES: /* HBB: I think these should be here... */
! 895: case STEPS:
! 896: case FSTEPS:
! 897: case HISTEPS:
! 898: key_sample_line(xl, yl);
! 899: break;
! 900: case YERRORBARS: /* ignored; treat like points */
! 901: case XERRORBARS: /* ignored; treat like points */
! 902: case XYERRORBARS: /* ignored; treat like points */
! 903: case BOXERROR: /* HBB: ignore these as well */
! 904: case BOXXYERROR:
! 905: case CANDLESTICKS: /* HBB: dito */
! 906: case FINANCEBARS:
! 907: case VECTOR:
! 908: case POINTSTYLE:
! 909: key_sample_point(xl, yl, this_plot->lp_properties.p_type);
! 910: break;
! 911: case LINESPOINTS:
! 912: key_sample_line(xl, yl);
! 913: break;
! 914: case DOTS:
! 915: key_sample_point(xl, yl, -1);
! 916: break;
! 917: }
! 918: NEXT_KEY_LINE();
! 919: }
! 920: linetypeOffset = this_plot->lp_properties.l_type + (hidden3d ? 2 : 1);
! 921: while (cntrs) {
! 922: if (label_contours && cntrs->isNewLevel) {
! 923: (*t->linetype) (linetypeOffset++);
! 924: if (key) {
! 925:
! 926: #ifndef LITE
! 927: if (hidden3d)
! 928: hidden_line_type_below = hidden_line_type_above = linetypeOffset - 1;
! 929: #endif /* not LITE */
! 930:
! 931: key_text(xl, yl, cntrs->label);
! 932:
! 933: switch (this_plot->plot_style) {
! 934: case IMPULSES:
! 935: case LINES:
! 936: case LINESPOINTS:
! 937: case BOXES: /* HBB: these should be treated as well... */
! 938: case STEPS:
! 939: case FSTEPS:
! 940: case HISTEPS:
! 941: key_sample_line(xl, yl);
! 942: break;
! 943: case YERRORBARS: /* ignored; treat like points */
! 944: case XERRORBARS: /* ignored; treat like points */
! 945: case XYERRORBARS: /* ignored; treat like points */
! 946: case BOXERROR: /* HBB: treat these likewise */
! 947: case BOXXYERROR:
! 948: case CANDLESTICKS: /* HBB: dito */
! 949: case FINANCEBARS:
! 950: case VECTOR:
! 951: case POINTSTYLE:
! 952: key_sample_point(xl, yl, this_plot->lp_properties.p_type);
! 953: break;
! 954: case DOTS:
! 955: key_sample_point(xl, yl, -1);
! 956: break;
! 957: } /* switch */
! 958:
! 959: NEXT_KEY_LINE();
! 960:
! 961: } /* key */
! 962: } /* label_contours */
! 963: /* now draw the contour */
! 964: switch (this_plot->plot_style) {
! 965: case IMPULSES:
! 966: case BOXES: /* HBB: this should also be treated somehow */
! 967: cntr3d_impulses(cntrs, this_plot);
! 968: break;
! 969: case LINES:
! 970: case STEPS: /* HBB: these should also be handled, I think */
! 971: case FSTEPS:
! 972: case HISTEPS:
! 973: cntr3d_lines(cntrs);
! 974: break;
! 975: case YERRORBARS: /* ignored; treat like points */
! 976: case XERRORBARS: /* ignored; treat like points */
! 977: case XYERRORBARS: /* ignored; treat like points */
! 978: case BOXERROR: /* HBB: ignore these too... */
! 979: case BOXXYERROR:
! 980: case CANDLESTICKS: /* HBB: dito */
! 981: case FINANCEBARS:
! 982: case VECTOR:
! 983: case POINTSTYLE:
! 984: cntr3d_points(cntrs, this_plot);
! 985: break;
! 986: case LINESPOINTS:
! 987: cntr3d_lines(cntrs);
! 988: cntr3d_points(cntrs, this_plot);
! 989: break;
! 990: case DOTS:
! 991: cntr3d_dots(cntrs);
! 992: break;
! 993: } /*switch */
! 994:
! 995: cntrs = cntrs->next;
! 996: } /* loop over contours */
! 997: } /* draw contours */
! 998: } /* loop over surfaces */
! 999:
! 1000: draw_bottom_grid(plots, pcount);
! 1001:
! 1002: term_end_plot();
! 1003:
! 1004: #ifndef LITE
! 1005: if (hidden3d && draw_surface) {
! 1006: term_hidden_line_removal();
! 1007: hidden_active = FALSE;
! 1008: }
! 1009: #endif /* not LITE */
! 1010:
! 1011: }
! 1012:
! 1013: /* plot3d_impulses:
! 1014: * Plot the surfaces in IMPULSES style
! 1015: */
! 1016: static void plot3d_impulses(plot)
! 1017: struct surface_points *plot;
! 1018: {
! 1019: int i; /* point index */
! 1020: unsigned int x, y, x0, y0; /* point in terminal coordinates */
! 1021: struct iso_curve *icrvs = plot->iso_crvs;
! 1022:
! 1023: while (icrvs) {
! 1024: struct coordinate GPHUGE *points = icrvs->points;
! 1025:
! 1026: for (i = 0; i < icrvs->p_count; i++) {
! 1027: switch (points[i].type) {
! 1028: case INRANGE:
! 1029: {
! 1030: map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
! 1031:
! 1032: if (inrange(0.0, min3d_z, max3d_z)) {
! 1033: map3d_xy(points[i].x, points[i].y, 0.0, &x0, &y0);
! 1034: } else if (inrange(min3d_z, 0.0, points[i].z)) {
! 1035: map3d_xy(points[i].x, points[i].y, min3d_z, &x0, &y0);
! 1036: } else {
! 1037: map3d_xy(points[i].x, points[i].y, max3d_z, &x0, &y0);
! 1038: }
! 1039:
! 1040: clip_move(x0, y0);
! 1041: clip_vector(x, y);
! 1042:
! 1043: break;
! 1044: }
! 1045: case OUTRANGE:
! 1046: {
! 1047: if (!inrange(points[i].x, x_min3d, x_max3d) ||
! 1048: !inrange(points[i].y, y_min3d, y_max3d))
! 1049: break;
! 1050:
! 1051: if (inrange(0.0, min3d_z, max3d_z)) {
! 1052: /* zero point is INRANGE */
! 1053: map3d_xy(points[i].x, points[i].y, 0.0, &x0, &y0);
! 1054:
! 1055: /* must cross z = min3d_z or max3d_z limits */
! 1056: if (inrange(min3d_z, 0.0, points[i].z) &&
! 1057: min3d_z != 0.0 && min3d_z != points[i].z) {
! 1058: map3d_xy(points[i].x, points[i].y, min3d_z, &x, &y);
! 1059: } else {
! 1060: map3d_xy(points[i].x, points[i].y, max3d_z, &x, &y);
! 1061: }
! 1062: } else {
! 1063: /* zero point is also OUTRANGE */
! 1064: if (inrange(min3d_z, 0.0, points[i].z) &&
! 1065: inrange(max3d_z, 0.0, points[i].z)) {
! 1066: /* crosses z = min3d_z or max3d_z limits */
! 1067: map3d_xy(points[i].x, points[i].y, max3d_z, &x, &y);
! 1068: map3d_xy(points[i].x, points[i].y, min3d_z, &x0, &y0);
! 1069: } else {
! 1070: /* doesn't cross z = min3d_z or max3d_z limits */
! 1071: break;
! 1072: }
! 1073: }
! 1074:
! 1075: clip_move(x0, y0);
! 1076: clip_vector(x, y);
! 1077:
! 1078: break;
! 1079: }
! 1080: default: /* just a safety */
! 1081: case UNDEFINED:{
! 1082: break;
! 1083: }
! 1084: }
! 1085: }
! 1086:
! 1087: icrvs = icrvs->next;
! 1088: }
! 1089: }
! 1090:
! 1091: /* plot3d_lines:
! 1092: * Plot the surfaces in LINES style
! 1093: */
! 1094: /* We want to always draw the lines in the same direction, otherwise when
! 1095: we draw an adjacent box we might get the line drawn a little differently
! 1096: and we get splotches. */
! 1097:
! 1098: static void plot3d_lines(plot)
! 1099: struct surface_points *plot;
! 1100: {
! 1101: int i;
! 1102: unsigned int x, y, x0, y0; /* point in terminal coordinates */
! 1103: double clip_x, clip_y, clip_z;
! 1104: struct iso_curve *icrvs = plot->iso_crvs;
! 1105: struct coordinate GPHUGE *points;
! 1106: enum coord_type prev = UNDEFINED;
! 1107: double lx[2], ly[2], lz[2]; /* two edge points */
! 1108:
! 1109: #ifndef LITE
! 1110: /* These are handled elsewhere. */
! 1111: if (plot->has_grid_topology && hidden3d)
! 1112: return;
! 1113: #endif /* not LITE */
! 1114:
! 1115: while (icrvs) {
! 1116: prev = UNDEFINED; /* type of previous plot */
! 1117:
! 1118: for (i = 0, points = icrvs->points; i < icrvs->p_count; i++) {
! 1119: switch (points[i].type) {
! 1120: case INRANGE:{
! 1121: map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
! 1122:
! 1123: if (prev == INRANGE) {
! 1124: clip_vector(x, y);
! 1125: } else {
! 1126: if (prev == OUTRANGE) {
! 1127: /* from outrange to inrange */
! 1128: if (!clip_lines1) {
! 1129: clip_move(x, y);
! 1130: } else {
! 1131: /*
! 1132: * Calculate intersection point and draw
! 1133: * vector from there
! 1134: */
! 1135: edge3d_intersect(points, i, &clip_x, &clip_y, &clip_z);
! 1136:
! 1137: map3d_xy(clip_x, clip_y, clip_z, &x0, &y0);
! 1138:
! 1139: clip_move(x0, y0);
! 1140: clip_vector(x, y);
! 1141: }
! 1142: } else {
! 1143: clip_move(x, y);
! 1144: }
! 1145: }
! 1146:
! 1147: break;
! 1148: }
! 1149: case OUTRANGE:{
! 1150: if (prev == INRANGE) {
! 1151: /* from inrange to outrange */
! 1152: if (clip_lines1) {
! 1153: /*
! 1154: * Calculate intersection point and draw
! 1155: * vector to it
! 1156: */
! 1157:
! 1158: edge3d_intersect(points, i, &clip_x, &clip_y, &clip_z);
! 1159:
! 1160: map3d_xy(clip_x, clip_y, clip_z, &x0, &y0);
! 1161:
! 1162: clip_vector(x0, y0);
! 1163: }
! 1164: } else if (prev == OUTRANGE) {
! 1165: /* from outrange to outrange */
! 1166: if (clip_lines2) {
! 1167: /*
! 1168: * Calculate the two 3D intersection points
! 1169: * if present
! 1170: */
! 1171: if (two_edge3d_intersect(points, i, lx, ly, lz)) {
! 1172:
! 1173: map3d_xy(lx[0], ly[0], lz[0], &x, &y);
! 1174:
! 1175: map3d_xy(lx[1], ly[1], lz[1], &x0, &y0);
! 1176:
! 1177: clip_move(x, y);
! 1178: clip_vector(x0, y0);
! 1179: }
! 1180: }
! 1181: }
! 1182: break;
! 1183: }
! 1184: case UNDEFINED:{
! 1185: break;
! 1186: default:
! 1187: graph_error("Unknown point type in plot3d_lines");
! 1188: }
! 1189: }
! 1190:
! 1191: prev = points[i].type;
! 1192: }
! 1193:
! 1194: icrvs = icrvs->next;
! 1195: }
! 1196: }
! 1197:
! 1198: /* plot3d_points:
! 1199: * Plot the surfaces in POINTSTYLE style
! 1200: */
! 1201: static void plot3d_points(plot)
! 1202: struct surface_points *plot;
! 1203: {
! 1204: int i;
! 1205: unsigned int x, y;
! 1206: struct termentry *t = term;
! 1207: struct iso_curve *icrvs = plot->iso_crvs;
! 1208:
! 1209: while (icrvs) {
! 1210: struct coordinate GPHUGE *points = icrvs->points;
! 1211:
! 1212: for (i = 0; i < icrvs->p_count; i++) {
! 1213: if (points[i].type == INRANGE) {
! 1214: map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
! 1215:
! 1216: if (!clip_point(x, y))
! 1217: (*t->point) (x, y, plot->lp_properties.p_type);
! 1218: }
! 1219: }
! 1220:
! 1221: icrvs = icrvs->next;
! 1222: }
! 1223: }
! 1224:
! 1225: /* plot3d_dots:
! 1226: * Plot the surfaces in DOTS style
! 1227: */
! 1228: static void plot3d_dots(plot)
! 1229: struct surface_points *plot;
! 1230: {
! 1231: int i;
! 1232: struct termentry *t = term;
! 1233: struct iso_curve *icrvs = plot->iso_crvs;
! 1234:
! 1235: while (icrvs) {
! 1236: struct coordinate GPHUGE *points = icrvs->points;
! 1237:
! 1238: for (i = 0; i < icrvs->p_count; i++) {
! 1239: if (points[i].type == INRANGE) {
! 1240: unsigned int x, y;
! 1241: map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
! 1242:
! 1243: if (!clip_point(x, y))
! 1244: (*t->point) (x, y, -1);
! 1245: }
! 1246: }
! 1247:
! 1248: icrvs = icrvs->next;
! 1249: }
! 1250: }
! 1251:
! 1252: /* cntr3d_impulses:
! 1253: * Plot a surface contour in IMPULSES style
! 1254: */
! 1255: static void cntr3d_impulses(cntr, plot)
! 1256: struct gnuplot_contours *cntr;
! 1257: struct surface_points *plot;
! 1258: {
! 1259: int i; /* point index */
! 1260: unsigned int x, y, x0, y0; /* point in terminal coordinates */
! 1261:
! 1262: if (draw_contour & CONTOUR_SRF) {
! 1263: for (i = 0; i < cntr->num_pts; i++) {
! 1264: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z,
! 1265: &x, &y);
! 1266: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
! 1267: &x0, &y0);
! 1268:
! 1269: clip_move(x0, y0);
! 1270: clip_vector(x, y);
! 1271: }
! 1272: } else {
! 1273: /* Must be on base grid, so do points. */
! 1274: cntr3d_points(cntr, plot);
! 1275: }
! 1276: }
! 1277:
! 1278: /* cntr3d_lines:
! 1279: * Plot a surface contour in LINES style
! 1280: */
! 1281: static void cntr3d_lines(cntr)
! 1282: struct gnuplot_contours *cntr;
! 1283: {
! 1284: int i; /* point index */
! 1285: unsigned int x, y; /* point in terminal coordinates */
! 1286:
! 1287: if (draw_contour & CONTOUR_SRF) {
! 1288: for (i = 0; i < cntr->num_pts; i++) {
! 1289: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z,
! 1290: &x, &y);
! 1291:
! 1292: if (i > 0) {
! 1293: clip_vector(x, y);
! 1294: if (i == 1)
! 1295: suppressMove = TRUE;
! 1296: } else {
! 1297: clip_move(x, y);
! 1298: }
! 1299: }
! 1300: }
! 1301: /* beginning a new contour level, so moveto() required */
! 1302: suppressMove = FALSE;
! 1303:
! 1304: if (draw_contour & CONTOUR_BASE) {
! 1305: for (i = 0; i < cntr->num_pts; i++) {
! 1306: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
! 1307: &x, &y);
! 1308:
! 1309: if (i > 0) {
! 1310: clip_vector(x, y);
! 1311: if (i == 1)
! 1312: suppressMove = TRUE;
! 1313: } else {
! 1314: clip_move(x, y);
! 1315: }
! 1316: }
! 1317: }
! 1318: /* beginning a new contour level, so moveto() required */
! 1319: suppressMove = FALSE;
! 1320: }
! 1321:
! 1322: /* cntr3d_points:
! 1323: * Plot a surface contour in POINTSTYLE style
! 1324: */
! 1325: static void cntr3d_points(cntr, plot)
! 1326: struct gnuplot_contours *cntr;
! 1327: struct surface_points *plot;
! 1328: {
! 1329: int i;
! 1330: unsigned int x, y;
! 1331: struct termentry *t = term;
! 1332:
! 1333: if (draw_contour & CONTOUR_SRF) {
! 1334: for (i = 0; i < cntr->num_pts; i++) {
! 1335: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z, &x, &y);
! 1336:
! 1337: if (!clip_point(x, y))
! 1338: (*t->point) (x, y, plot->lp_properties.p_type);
! 1339: }
! 1340: }
! 1341: if (draw_contour & CONTOUR_BASE) {
! 1342: for (i = 0; i < cntr->num_pts; i++) {
! 1343: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
! 1344: &x, &y);
! 1345:
! 1346: if (!clip_point(x, y))
! 1347: (*t->point) (x, y, plot->lp_properties.p_type);
! 1348: }
! 1349: }
! 1350: }
! 1351:
! 1352: /* cntr3d_dots:
! 1353: * Plot a surface contour in DOTS style
! 1354: */
! 1355: static void cntr3d_dots(cntr)
! 1356: struct gnuplot_contours *cntr;
! 1357: {
! 1358: int i;
! 1359: unsigned int x, y;
! 1360: struct termentry *t = term;
! 1361:
! 1362: if (draw_contour & CONTOUR_SRF) {
! 1363: for (i = 0; i < cntr->num_pts; i++) {
! 1364: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, cntr->coords[i].z, &x, &y);
! 1365:
! 1366: if (!clip_point(x, y))
! 1367: (*t->point) (x, y, -1);
! 1368: }
! 1369: }
! 1370: if (draw_contour & CONTOUR_BASE) {
! 1371: for (i = 0; i < cntr->num_pts; i++) {
! 1372: map3d_xy(cntr->coords[i].x, cntr->coords[i].y, base_z,
! 1373: &x, &y);
! 1374:
! 1375: if (!clip_point(x, y))
! 1376: (*t->point) (x, y, -1);
! 1377: }
! 1378: }
! 1379: }
! 1380:
! 1381:
! 1382:
! 1383: /* map xmin | xmax to 0 | 1 and same for y
! 1384: * 0.1 avoids any rounding errors
! 1385: */
! 1386: #define MAP_HEIGHT_X(x) ( (int) (((x)-x_min3d)/(x_max3d-x_min3d)+0.1) )
! 1387: #define MAP_HEIGHT_Y(y) ( (int) (((y)-y_min3d)/(y_max3d-y_min3d)+0.1) )
! 1388:
! 1389: /* if point is at corner, update height[][] and depth[][]
! 1390: * we are still assuming that extremes of surfaces are at corners,
! 1391: * but we are not assuming order of corners
! 1392: */
! 1393: static void check_corner_height(p, height, depth)
! 1394: struct coordinate GPHUGE *p;
! 1395: double height[2][2];
! 1396: double depth[2][2];
! 1397: {
! 1398: if (p->type != INRANGE)
! 1399: return;
! 1400: if ((fabs(p->x - x_min3d) < zero || fabs(p->x - x_max3d) < zero) &&
! 1401: (fabs(p->y - y_min3d) < zero || fabs(p->y - y_max3d) < zero)) {
! 1402: unsigned int x = MAP_HEIGHT_X(p->x);
! 1403: unsigned int y = MAP_HEIGHT_Y(p->y);
! 1404: if (height[x][y] < p->z)
! 1405: height[x][y] = p->z;
! 1406: if (depth[x][y] > p->z)
! 1407: depth[x][y] = p->z;
! 1408: }
! 1409: }
! 1410:
! 1411:
! 1412: /* Draw the bottom grid that hold the tic marks for 3d surface. */
! 1413: static void draw_bottom_grid(plot, plot_num)
! 1414: struct surface_points *plot;
! 1415: int plot_num;
! 1416: {
! 1417: unsigned int x, y; /* point in terminal coordinates */
! 1418: struct termentry *t = term;
! 1419: char ss[MAX_LINE_LEN+1];
! 1420:
! 1421: /* work out where the axes and tics are drawn */
! 1422:
! 1423: {
! 1424: int quadrant = surface_rot_z / 90;
! 1425: if ((quadrant + 1) & 2) {
! 1426: zaxis_x = x_max3d;
! 1427: xaxis_y = y_max3d;
! 1428: } else {
! 1429: zaxis_x = x_min3d;
! 1430: xaxis_y = y_min3d;
! 1431: }
! 1432:
! 1433: if (quadrant & 2) {
! 1434: zaxis_y = y_max3d;
! 1435: yaxis_x = x_min3d;
! 1436: } else {
! 1437: zaxis_y = y_min3d;
! 1438: yaxis_x = x_max3d;
! 1439: }
! 1440:
! 1441: if (surface_rot_x > 90) {
! 1442: /* labels on the back axes */
! 1443: back_x = yaxis_x = x_min3d + x_max3d - yaxis_x;
! 1444: back_y = xaxis_y = y_min3d + y_max3d - xaxis_y;
! 1445: } else {
! 1446: back_x = x_min3d + x_max3d - yaxis_x;
! 1447: back_y = y_min3d + y_max3d - xaxis_y;
! 1448: }
! 1449: }
! 1450:
! 1451: if (draw_border) {
! 1452: unsigned int bl_x, bl_y; /* bottom left */
! 1453: unsigned int bb_x, bb_y; /* bottom back */
! 1454: unsigned int br_x, br_y; /* bottom right */
! 1455: unsigned int bf_x, bf_y; /* bottom front */
! 1456:
! 1457: #ifndef LITE
! 1458: int save_update = hidden_no_update;
! 1459: hidden_no_update = TRUE;
! 1460: #endif /* LITE */
! 1461:
! 1462: /* Here is the one and only call to this function. */
! 1463: setlinestyle(border_lp);
! 1464:
! 1465: map3d_xy(zaxis_x, zaxis_y, base_z, &bl_x, &bl_y);
! 1466: map3d_xy(back_x, back_y, base_z, &bb_x, &bb_y);
! 1467: map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, base_z, &br_x, &br_y);
! 1468: map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, base_z, &bf_x, &bf_y);
! 1469:
! 1470: /* border around base */
! 1471: {
! 1472: int save = hidden_active;
! 1473: hidden_active = FALSE; /* this is in front */
! 1474: if (draw_border & 4)
! 1475: draw_clip_line(br_x, br_y, bf_x, bf_y);
! 1476: if (draw_border & 1)
! 1477: draw_clip_line(bl_x, bl_y, bf_x, bf_y);
! 1478: hidden_active = save;
! 1479: }
! 1480: if (draw_border & 2)
! 1481: draw_clip_line(bl_x, bl_y, bb_x, bb_y);
! 1482: if (draw_border & 8)
! 1483: draw_clip_line(br_x, br_y, bb_x, bb_y);
! 1484:
! 1485: if (draw_surface || (draw_contour & CONTOUR_SRF)) {
! 1486: int save = hidden_active;
! 1487: /* map the 8 corners to screen */
! 1488: unsigned int fl_x, fl_y; /* floor left */
! 1489: unsigned int fb_x, fb_y; /* floor back */
! 1490: unsigned int fr_x, fr_y; /* floor right */
! 1491: unsigned int ff_x, ff_y; /* floor front */
! 1492:
! 1493: unsigned int tl_x, tl_y; /* top left */
! 1494: unsigned int tb_x, tb_y; /* top back */
! 1495: unsigned int tr_x, tr_y; /* top right */
! 1496: unsigned int tf_x, tf_y; /* top front */
! 1497:
! 1498: map3d_xy(zaxis_x, zaxis_y, floor_z, &fl_x, &fl_y);
! 1499: map3d_xy(back_x, back_y, floor_z, &fb_x, &fb_y);
! 1500: map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, floor_z, &fr_x, &fr_y);
! 1501: map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, floor_z, &ff_x, &ff_y);
! 1502:
! 1503: map3d_xy(zaxis_x, zaxis_y, ceiling_z, &tl_x, &tl_y);
! 1504: map3d_xy(back_x, back_y, ceiling_z, &tb_x, &tb_y);
! 1505: map3d_xy(x_min3d + x_max3d - zaxis_x, y_min3d + y_max3d - zaxis_y, ceiling_z, &tr_x, &tr_y);
! 1506: map3d_xy(x_min3d + x_max3d - back_x, y_min3d + y_max3d - back_y, ceiling_z, &tf_x, &tf_y);
! 1507:
! 1508: /* vertical lines, to surface or to very top */
! 1509: if ((draw_border & 0xf0) == 0xf0) {
! 1510: /* all four verticals drawn - save some time */
! 1511: draw_clip_line(fl_x, fl_y, tl_x, tl_y);
! 1512: draw_clip_line(fb_x, fb_y, tb_x, tb_y);
! 1513: draw_clip_line(fr_x, fr_y, tr_x, tr_y);
! 1514: hidden_active = FALSE; /* this is in front */
! 1515: draw_clip_line(ff_x, ff_y, tf_x, tf_y);
! 1516: hidden_active = save;
! 1517: } else {
! 1518: /* search surfaces for heights at corners */
! 1519: double height[2][2];
! 1520: double depth[2][2];
! 1521: unsigned int zaxis_i = MAP_HEIGHT_X(zaxis_x);
! 1522: unsigned int zaxis_j = MAP_HEIGHT_Y(zaxis_y);
! 1523: unsigned int back_i = MAP_HEIGHT_X(back_x);
! 1524: /* HBB: why isn't back_j unsigned ??? */
! 1525: int back_j = MAP_HEIGHT_Y(back_y);
! 1526:
! 1527: height[0][0] = height[0][1] = height[1][0] = height[1][1] = base_z;
! 1528: depth[0][0] = depth[0][1] = depth[1][0] = depth[1][1] = base_z;
! 1529:
! 1530: for (; --plot_num >= 0; plot = plot->next_sp) {
! 1531: struct iso_curve *curve = plot->iso_crvs;
! 1532: int count = curve->p_count;
! 1533: int iso;
! 1534: if (plot->plot_type == DATA3D) {
! 1535: if (!plot->has_grid_topology)
! 1536: continue;
! 1537: iso = plot->num_iso_read;
! 1538: } else
! 1539: iso = iso_samples_2;
! 1540:
! 1541: check_corner_height(curve->points, height, depth);
! 1542: check_corner_height(curve->points + count - 1, height, depth);
! 1543: while (--iso)
! 1544: curve = curve->next;
! 1545: check_corner_height(curve->points, height, depth);
! 1546: check_corner_height(curve->points + count - 1, height, depth);
! 1547: }
! 1548:
! 1549: #define VERTICAL(mask,x,y,i,j,bx,by,tx,ty) \
! 1550: if (draw_border&mask) \
! 1551: draw_clip_line(bx,by,tx,ty);\
! 1552: else if (height[i][j] != depth[i][j]) \
! 1553: { unsigned int a0,b0, a1, b1; \
! 1554: map3d_xy(x,y,depth[i][j],&a0,&b0); \
! 1555: map3d_xy(x,y,height[i][j],&a1,&b1); \
! 1556: draw_clip_line(a0,b0,a1,b1); \
! 1557: }
! 1558:
! 1559: VERTICAL(16,zaxis_x,zaxis_y,zaxis_i,zaxis_j,fl_x,fl_y,tl_x,tl_y);
! 1560: VERTICAL(32,back_x,back_y,back_i,back_j,fb_x,fb_y,tb_x,tb_y);
! 1561: VERTICAL(64,x_min3d+x_max3d-zaxis_x,y_min3d+y_max3d-zaxis_y,1-zaxis_i,1-zaxis_j,fr_x,fr_y,tr_x,tr_y);
! 1562: hidden_active = FALSE;
! 1563: VERTICAL(128,x_min3d+x_max3d-back_x,y_min3d+y_max3d-back_y,1-back_i,1-back_j,ff_x,ff_y,tf_x,tf_y);
! 1564: hidden_active = save;
! 1565: }
! 1566:
! 1567: /* now border lines on top */
! 1568: if (draw_border & 256)
! 1569: draw_clip_line(tl_x, tl_y, tb_x, tb_y);
! 1570: if (draw_border & 512)
! 1571: draw_clip_line(tr_x, tr_y, tb_x, tb_y);
! 1572: /* these lines are in front of surface (?) */
! 1573: hidden_active = FALSE;
! 1574: if (draw_border & 1024)
! 1575: draw_clip_line(tl_x, tl_y, tf_x, tf_y);
! 1576: if (draw_border & 2048)
! 1577: draw_clip_line(tr_x, tr_y, tf_x, tf_y);
! 1578: hidden_active = save;
! 1579: }
! 1580:
! 1581: #ifndef LITE
! 1582: hidden_no_update = save_update;
! 1583: #endif /* LITE */
! 1584:
! 1585: }
! 1586: if (xtics || *xlabel.text) {
! 1587: unsigned int x0, y0, x1, y1;
! 1588: double mid_x = (x_max3d + x_min3d) / 2;
! 1589: double len;
! 1590: map3d_xy(mid_x, xaxis_y, base_z, &x0, &y0);
! 1591: map3d_xy(mid_x, y_min3d + y_max3d - xaxis_y, base_z, &x1, &y1);
! 1592: { /* take care over unsigned quantities */
! 1593: int dx = x1 - x0;
! 1594: int dy = y1 - y0;
! 1595: /* HBB 980309: 16bit strikes back: */
! 1596: len = sqrt(((double) dx) * dx + ((double) dy) * dy);
! 1597: if (len != 0) {
! 1598: tic_unitx = dx / len;
! 1599: tic_unity = dy / len;
! 1600: } else {
! 1601: tic_unitx = tic_unity = 0;
! 1602: }
! 1603: }
! 1604:
! 1605: if (xtics) {
! 1606: gen_tics(FIRST_X_AXIS, &xticdef,
! 1607: work_grid.l_type & (GRID_X | GRID_MX),
! 1608: mxtics, mxtfreq, xtick_callback);
! 1609: }
! 1610: if (*xlabel.text) {
! 1611: /* label at xaxis_y + 1/4 of (xaxis_y-other_y) */
! 1612: double step = (2 * xaxis_y - y_max3d - y_min3d) / 4;
! 1613: map3d_xy(mid_x, xaxis_y + step, base_z, &x1, &y1);
! 1614: x1 += xlabel.xoffset * t->h_char;
! 1615: y1 += xlabel.yoffset * t->v_char;
! 1616: if (!tic_in) {
! 1617: x1 -= tic_unitx * ticscale * (t->h_tic);
! 1618: y1 -= tic_unity * ticscale * (t->v_tic);
! 1619: }
! 1620: /* write_multiline mods it */
! 1621: safe_strncpy(ss, xlabel.text, sizeof(ss));
! 1622: write_multiline(x1, y1, ss, CENTRE, JUST_TOP, 0, xlabel.font);
! 1623: }
! 1624: }
! 1625: if (ytics || *ylabel.text) {
! 1626: unsigned int x0, y0, x1, y1;
! 1627: double mid_y = (y_max3d + y_min3d) / 2;
! 1628: double len;
! 1629: map3d_xy(yaxis_x, mid_y, base_z, &x0, &y0);
! 1630: map3d_xy(x_min3d + x_max3d - yaxis_x, mid_y, base_z, &x1, &y1);
! 1631: { /* take care over unsigned quantities */
! 1632: int dx = x1 - x0;
! 1633: int dy = y1 - y0;
! 1634: /* HBB 980309: 16 Bits strike again: */
! 1635: len = sqrt(((double) dx) * dx + ((double) dy) * dy);
! 1636: if (len != 0) {
! 1637: tic_unitx = dx / len;
! 1638: tic_unity = dy / len;
! 1639: } else {
! 1640: tic_unitx = tic_unity = 0;
! 1641: }
! 1642: }
! 1643: if (ytics) {
! 1644: gen_tics(FIRST_Y_AXIS, &yticdef,
! 1645: work_grid.l_type & (GRID_Y | GRID_MY),
! 1646: mytics, mytfreq, ytick_callback);
! 1647: }
! 1648: if (*ylabel.text) {
! 1649: double step = (x_max3d + x_min3d - 2 * yaxis_x) / 4;
! 1650: map3d_xy(yaxis_x - step, mid_y, base_z, &x1, &y1);
! 1651: x1 += ylabel.xoffset * t->h_char;
! 1652: y1 += ylabel.yoffset * t->v_char;
! 1653: if (!tic_in) {
! 1654: x1 -= tic_unitx * ticscale * (t->h_tic);
! 1655: y1 -= tic_unity * ticscale * (t->v_tic);
! 1656: }
! 1657: /* write_multiline mods it */
! 1658: safe_strncpy(ss, ylabel.text, sizeof(ss));
! 1659: write_multiline(x1, y1, ss, CENTRE, JUST_TOP, 0, ylabel.font);
! 1660: }
! 1661: }
! 1662: /* do z tics */
! 1663:
! 1664: if (ztics && (draw_surface || (draw_contour & CONTOUR_SRF))) {
! 1665: gen_tics(FIRST_Z_AXIS, &zticdef, work_grid.l_type & (GRID_Z | GRID_MZ),
! 1666: mztics, mztfreq, ztick_callback);
! 1667: }
! 1668: if ((xzeroaxis.l_type >= -2) && !is_log_y && inrange(0, y_min3d, y_max3d)) {
! 1669: unsigned int x, y, x1, y1;
! 1670: term_apply_lp_properties(&xzeroaxis);
! 1671: map3d_xy(0.0, y_min3d, base_z, &x, &y); /* line through x=0 */
! 1672: map3d_xy(0.0, y_max3d, base_z, &x1, &y1);
! 1673: draw_clip_line(x, y, x1, y1);
! 1674: }
! 1675: if ((yzeroaxis.l_type >= -2) && !is_log_x && inrange(0, x_min3d, x_max3d)) {
! 1676: unsigned int x, y, x1, y1;
! 1677: term_apply_lp_properties(&yzeroaxis);
! 1678: map3d_xy(x_min3d, 0.0, base_z, &x, &y); /* line through y=0 */
! 1679: map3d_xy(x_max3d, 0.0, base_z, &x1, &y1);
! 1680: draw_clip_line(x, y, x1, y1);
! 1681: }
! 1682: /* PLACE ZLABEL - along the middle grid Z axis - eh ? */
! 1683: if (*zlabel.text && (draw_surface || (draw_contour & CONTOUR_SRF))) {
! 1684: map3d_xy(zaxis_x, zaxis_y, z_max3d + (z_max3d - base_z) / 4, &x, &y);
! 1685:
! 1686: x += zlabel.xoffset * t->h_char;
! 1687: y += zlabel.yoffset * t->v_char;
! 1688:
! 1689: safe_strncpy(ss, zlabel.text, sizeof(ss));
! 1690: write_multiline(x, y, ss, CENTRE, CENTRE, 0, zlabel.font);
! 1691:
! 1692: }
! 1693: }
! 1694:
! 1695:
! 1696: static void xtick_callback(axis, place, text, grid)
! 1697: int axis;
! 1698: double place;
! 1699: char *text;
! 1700: struct lp_style_type grid; /* linetype or -2 for none */
! 1701: {
! 1702: unsigned int x, y, x1, y1;
! 1703: double scale = (text ? ticscale : miniticscale);
! 1704: int dirn = tic_in ? 1 : -1;
! 1705: register struct termentry *t = term;
! 1706:
! 1707: map3d_xy(place, xaxis_y, base_z, &x, &y);
! 1708: if (grid.l_type > -2) {
! 1709: term_apply_lp_properties(&grid);
! 1710: /* to save mapping twice, map non-axis y */
! 1711: map3d_xy(place, y_min3d + y_max3d - xaxis_y, base_z, &x1, &y1);
! 1712: draw_clip_line(x, y, x1, y1);
! 1713: term_apply_lp_properties(&border_lp);
! 1714: }
! 1715: if (xtics & TICS_ON_AXIS) {
! 1716: map3d_xy(place, (y_min3d + y_max3d) / 2, base_z, &x, &y);
! 1717: }
! 1718: x1 = x + tic_unitx * scale * (t->h_tic) * dirn;
! 1719: y1 = y + tic_unity * scale * (t->v_tic) * dirn;
! 1720: draw_clip_line(x, y, x1, y1);
! 1721: if (text) {
! 1722: int just;
! 1723: if (tic_unitx < -0.9)
! 1724: just = LEFT;
! 1725: else if (tic_unitx < 0.9)
! 1726: just = CENTRE;
! 1727: else
! 1728: just = RIGHT;
! 1729: #if 1
! 1730: /* HBB 970729: let's see if the 'tic labels collide with axes' problem
! 1731: * may be fixed this way: */
! 1732: x1 = x - tic_unitx * (t->h_char) * 1;
! 1733: y1 = y - tic_unity * (t->v_char) * 1;
! 1734: #else
! 1735: x1 = x - tic_unitx * (t->h_tic) * 2;
! 1736: y1 = y - tic_unity * (t->v_tic) * 2;
! 1737: #endif
! 1738: if (!tic_in) {
! 1739: x1 -= tic_unitx * (t->h_tic) * ticscale;
! 1740: y1 -= tic_unity * (t->v_tic) * ticscale;
! 1741: }
! 1742: clip_put_text_just(x1, y1, text, just);
! 1743: }
! 1744: if (xtics & TICS_MIRROR) {
! 1745: map3d_xy(place, y_min3d + y_max3d - xaxis_y, base_z, &x, &y);
! 1746: x1 = x - tic_unitx * scale * (t->h_tic) * dirn;
! 1747: y1 = y - tic_unity * scale * (t->v_tic) * dirn;
! 1748: draw_clip_line(x, y, x1, y1);
! 1749: }
! 1750: }
! 1751:
! 1752: static void ytick_callback(axis, place, text, grid)
! 1753: int axis;
! 1754: double place;
! 1755: char *text;
! 1756: struct lp_style_type grid;
! 1757: {
! 1758: unsigned int x, y, x1, y1;
! 1759: double scale = (text ? ticscale : miniticscale);
! 1760: int dirn = tic_in ? 1 : -1;
! 1761: register struct termentry *t = term;
! 1762:
! 1763: map3d_xy(yaxis_x, place, base_z, &x, &y);
! 1764: if (grid.l_type > -2) {
! 1765: term_apply_lp_properties(&grid);
! 1766: map3d_xy(x_min3d + x_max3d - yaxis_x, place, base_z, &x1, &y1);
! 1767: draw_clip_line(x, y, x1, y1);
! 1768: term_apply_lp_properties(&border_lp);
! 1769: }
! 1770: if (ytics & TICS_ON_AXIS) {
! 1771: map3d_xy((x_min3d + x_max3d) / 2, place, base_z, &x, &y);
! 1772: }
! 1773: x1 = x + tic_unitx * scale * dirn * (t->h_tic);
! 1774: y1 = y + tic_unity * scale * dirn * (t->v_tic);
! 1775: draw_clip_line(x, y, x1, y1);
! 1776: if (text) {
! 1777: int just;
! 1778: if (tic_unitx < -0.9)
! 1779: just = LEFT;
! 1780: else if (tic_unitx < 0.9)
! 1781: just = CENTRE;
! 1782: else
! 1783: just = RIGHT;
! 1784: #if 1
! 1785: /* HBB 970729: same as above in xtics_callback */
! 1786: x1 = x - tic_unitx * (t->h_char) * 1;
! 1787: y1 = y - tic_unity * (t->v_char) * 1;
! 1788: #else
! 1789: x1 = x - tic_unitx * (t->h_tic) * 2;
! 1790: y1 = y - tic_unity * (t->v_tic) * 2;
! 1791: #endif
! 1792: if (!tic_in) {
! 1793: x1 -= tic_unitx * (t->h_tic) * ticscale;
! 1794: y1 -= tic_unity * (t->v_tic) * ticscale;
! 1795: }
! 1796: clip_put_text_just(x1, y1, text, just);
! 1797: }
! 1798: if (ytics & TICS_MIRROR) {
! 1799: map3d_xy(x_min3d + x_max3d - yaxis_x, place, base_z, &x, &y);
! 1800: x1 = x - tic_unitx * scale * (t->h_tic) * dirn;
! 1801: y1 = y - tic_unity * scale * (t->v_tic) * dirn;
! 1802: draw_clip_line(x, y, x1, y1);
! 1803: }
! 1804: }
! 1805:
! 1806: static void ztick_callback(axis, place, text, grid)
! 1807: int axis;
! 1808: double place;
! 1809: char *text;
! 1810: struct lp_style_type grid;
! 1811: {
! 1812: /* HBB: inserted some ()'s to shut up gcc -Wall, here and below */
! 1813: int len = (text ? ticscale : miniticscale) * (tic_in ? 1 : -1) * (term->h_tic);
! 1814: unsigned int x, y;
! 1815:
! 1816: if (grid.l_type > -2) {
! 1817: unsigned int x1, y1, x2, y2, x3, y3;
! 1818: double other_x = x_min3d + x_max3d - zaxis_x;
! 1819: double other_y = y_min3d + y_max3d - zaxis_y;
! 1820: term_apply_lp_properties(&grid);
! 1821: map3d_xy(zaxis_x, zaxis_y, place, &x1, &y1);
! 1822: map3d_xy(back_x, back_y, place, &x2, &y2);
! 1823: map3d_xy(other_x, other_y, place, &x3, &y3);
! 1824: draw_clip_line(x1, y1, x2, y2);
! 1825: draw_clip_line(x2, y2, x3, y3);
! 1826: term_apply_lp_properties(&border_lp);
! 1827: }
! 1828: map3d_xy(zaxis_x, zaxis_y, place, &x, &y);
! 1829: draw_clip_line(x, y, x + len, y);
! 1830: if (text) {
! 1831: int x1 = x - (term->h_tic) * 2;
! 1832: if (!tic_in)
! 1833: x1 -= (term->h_tic) * ticscale;
! 1834: clip_put_text_just(x1, y, text, RIGHT);
! 1835: }
! 1836: if (ztics & TICS_MIRROR) {
! 1837: double other_x = x_min3d + x_max3d - zaxis_x;
! 1838: double other_y = y_min3d + y_max3d - zaxis_y;
! 1839: map3d_xy(other_x, other_y, place, &x, &y);
! 1840: draw_clip_line(x, y, x - len, y);
! 1841: }
! 1842: }
! 1843:
! 1844:
! 1845: static void map_position(pos, x, y, what)
! 1846: struct position *pos;
! 1847: unsigned int *x, *y;
! 1848: char *what;
! 1849: {
! 1850: double xpos = pos->x;
! 1851: double ypos = pos->y;
! 1852: double zpos = pos->z;
! 1853: int screens = 0; /* need either 0 or 3 screen co-ordinates */
! 1854:
! 1855: switch (pos->scalex) {
! 1856: case first_axes:
! 1857: case second_axes:
! 1858: xpos = LogScale(xpos, is_log_x, log_base_log_x, what, "x");
! 1859: break;
! 1860: case graph:
! 1861: xpos = min_array[FIRST_X_AXIS] +
! 1862: xpos * (max_array[FIRST_X_AXIS] - min_array[FIRST_X_AXIS]);
! 1863: break;
! 1864: case screen:
! 1865: ++screens;
! 1866: }
! 1867:
! 1868: switch (pos->scaley) {
! 1869: case first_axes:
! 1870: case second_axes:
! 1871: ypos = LogScale(ypos, is_log_y, log_base_log_y, what, "y");
! 1872: break;
! 1873: case graph:
! 1874: ypos = min_array[FIRST_Y_AXIS] +
! 1875: ypos * (max_array[FIRST_Y_AXIS] - min_array[FIRST_Y_AXIS]);
! 1876: break;
! 1877: case screen:
! 1878: ++screens;
! 1879: }
! 1880:
! 1881: switch (pos->scalez) {
! 1882: case first_axes:
! 1883: case second_axes:
! 1884: zpos = LogScale(zpos, is_log_z, log_base_log_z, what, "z");
! 1885: break;
! 1886: case graph:
! 1887: zpos = min_array[FIRST_Z_AXIS] +
! 1888: zpos * (max_array[FIRST_Z_AXIS] - min_array[FIRST_Z_AXIS]);
! 1889: break;
! 1890: case screen:
! 1891: ++screens;
! 1892: }
! 1893:
! 1894: if (screens == 0) {
! 1895: map3d_xy(xpos, ypos, zpos, x, y);
! 1896: return;
! 1897: }
! 1898: if (screens != 3) {
! 1899: graph_error("Cannot mix screen co-ordinates with other types");
! 1900: } {
! 1901: register struct termentry *t = term;
! 1902: *x = pos->x * (t->xmax) + 0.5;
! 1903: *y = pos->y * (t->ymax) + 0.5;
! 1904: }
! 1905:
! 1906: return;
! 1907: }
! 1908:
! 1909:
! 1910: /*
! 1911: * these code blocks were moved to functions, to make the code simpler
! 1912: */
! 1913:
! 1914: static void key_text(xl, yl, text)
! 1915: int xl, yl;
! 1916: char *text;
! 1917: {
! 1918: if (key_just == JLEFT && key == -1) {
! 1919: (*term->justify_text) (LEFT);
! 1920: (*term->put_text) (xl + key_text_left, yl, text);
! 1921: } else {
! 1922: if ((*term->justify_text) (RIGHT)) {
! 1923: if (key == 1)
! 1924: clip_put_text(xl + key_text_right, yl, text);
! 1925: else
! 1926: (*term->put_text) (xl + key_text_right, yl, text);
! 1927: } else {
! 1928: int x = xl + key_text_right - (term->h_char) * strlen(text);
! 1929: if (key == 1) {
! 1930: if (i_inrange(x, xleft, xright))
! 1931: clip_put_text(x, yl, text);
! 1932: } else {
! 1933: (*term->put_text) (x, yl, text);
! 1934: }
! 1935: }
! 1936: }
! 1937: }
! 1938:
! 1939: static void key_sample_line(xl, yl)
! 1940: int xl, yl;
! 1941: {
! 1942: if (key == -1) {
! 1943: (*term->move) (xl + key_sample_left, yl);
! 1944: (*term->vector) (xl + key_sample_right, yl);
! 1945: } else {
! 1946: /* HBB 981118: avoid crash if hidden3d sees a manually placed key:
! 1947: * simply turn off hidden-lining while we're drawing the key line: */
! 1948: int save_hidden_active = hidden_active;
! 1949: hidden_active = FALSE;
! 1950:
! 1951: clip_move(xl + key_sample_left, yl);
! 1952: clip_vector(xl + key_sample_right, yl);
! 1953: hidden_active = save_hidden_active;
! 1954: }
! 1955: }
! 1956:
! 1957: static void key_sample_point(xl, yl, pointtype)
! 1958: int xl, yl;
! 1959: int pointtype;
! 1960: {
! 1961: if (!clip_point(xl + key_point_offset, yl)) {
! 1962: (*term->point) (xl + key_point_offset, yl, pointtype);
! 1963: } else {
! 1964: (*term->point) (xl + key_point_offset, yl, pointtype);
! 1965: }
! 1966: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to graph3d.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot