Annotation of OpenXM_contrib/gnuplot/util3d.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: util3d.c,v 1.17 1998/06/18 14:55:20 ddenholm Exp $";
! 3: #endif
! 4:
! 5:
! 6: /* GNUPLOT - util3d.c */
! 7:
! 8: /*[
! 9: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 10: *
! 11: * Permission to use, copy, and distribute this software and its
! 12: * documentation for any purpose with or without fee is hereby granted,
! 13: * provided that the above copyright notice appear in all copies and
! 14: * that both that copyright notice and this permission notice appear
! 15: * in supporting documentation.
! 16: *
! 17: * Permission to modify the software is granted, but not the right to
! 18: * distribute the complete modified source code. Modifications are to
! 19: * be distributed as patches to the released version. Permission to
! 20: * distribute binaries produced by compiling modified sources is granted,
! 21: * provided you
! 22: * 1. distribute the corresponding source modifications from the
! 23: * released version in the form of a patch file along with the binaries,
! 24: * 2. add special version identification to distinguish your version
! 25: * in addition to the base release version number,
! 26: * 3. provide your name and address as the primary contact for the
! 27: * support of your modified version, and
! 28: * 4. retain our contact information in regard to use of the base
! 29: * software.
! 30: * Permission to distribute the released version of the source code along
! 31: * with corresponding source modifications in the form of a patch file is
! 32: * granted with same provisions 2 through 4 for binary distributions.
! 33: *
! 34: * This software is provided "as is" without express or implied warranty
! 35: * to the extent permitted by applicable law.
! 36: ]*/
! 37:
! 38:
! 39: /*
! 40: * 19 September 1992 Lawrence Crowl (crowl@cs.orst.edu)
! 41: * Added user-specified bases for log scaling.
! 42: *
! 43: * 3.6 - split graph3d.c into graph3d.c (graph),
! 44: * util3d.c (intersections, etc)
! 45: * hidden3d.c (hidden-line removal code)
! 46: *
! 47: */
! 48:
! 49: #include "plot.h"
! 50: #include "setshow.h"
! 51:
! 52: extern int xleft,xright,ybot,ytop;
! 53: extern int hidden_active; /* HBB 980324: hidden_no_update was unused here */
! 54:
! 55: /* ACCESS THINGS THAT OUGHT TO BE HIDDEN IN hidden3d.c - perhaps we
! 56: * can move the relevant code into hidden3d.c sometime
! 57: */
! 58:
! 59: /* Bitmap of the screen. The array for each x value is malloc-ed as needed */
! 60:
! 61: extern int suppressMove;
! 62:
! 63: extern double min_array[], max_array[];
! 64: extern int auto_array[], log_array[];
! 65: extern double base_array[], log_base_array[];
! 66:
! 67: /* for convenience while converting to use these arrays */
! 68: #define x_min3d min_array[FIRST_X_AXIS]
! 69: #define x_max3d max_array[FIRST_X_AXIS]
! 70: #define y_min3d min_array[FIRST_Y_AXIS]
! 71: #define y_max3d max_array[FIRST_Y_AXIS]
! 72: #define z_min3d min_array[FIRST_Z_AXIS]
! 73: #define z_max3d max_array[FIRST_Z_AXIS]
! 74: #define min3d_z min_array[FIRST_Z_AXIS]
! 75: #define max3d_z max_array[FIRST_Z_AXIS]
! 76:
! 77: typedef double transform_matrix[4][4];
! 78:
! 79: void mat_unit(mat)
! 80: transform_matrix mat;
! 81: {
! 82: int i, j;
! 83:
! 84: for (i = 0; i < 4; i++) for (j = 0; j < 4; j++)
! 85: if (i == j)
! 86: mat[i][j] = 1.0;
! 87: else
! 88: mat[i][j] = 0.0;
! 89: }
! 90:
! 91: void mat_trans(tx, ty, tz, mat)
! 92: double tx, ty, tz;
! 93: transform_matrix mat;
! 94: {
! 95: mat_unit(mat); /* Make it unit matrix. */
! 96: mat[3][0] = tx;
! 97: mat[3][1] = ty;
! 98: mat[3][2] = tz;
! 99: }
! 100:
! 101: void mat_scale(sx, sy, sz, mat)
! 102: double sx, sy, sz;
! 103: transform_matrix mat;
! 104: {
! 105: mat_unit(mat); /* Make it unit matrix. */
! 106: mat[0][0] = sx;
! 107: mat[1][1] = sy;
! 108: mat[2][2] = sz;
! 109: }
! 110:
! 111: void mat_rot_x(teta, mat)
! 112: double teta;
! 113: transform_matrix mat;
! 114: {
! 115: double cos_teta, sin_teta;
! 116:
! 117: teta *= Pi / 180.0;
! 118: cos_teta = cos(teta);
! 119: sin_teta = sin(teta);
! 120:
! 121: mat_unit(mat); /* Make it unit matrix. */
! 122: mat[1][1] = cos_teta;
! 123: mat[1][2] = -sin_teta;
! 124: mat[2][1] = sin_teta;
! 125: mat[2][2] = cos_teta;
! 126: }
! 127:
! 128: void mat_rot_y(teta, mat)
! 129: double teta;
! 130: transform_matrix mat;
! 131: {
! 132: double cos_teta, sin_teta;
! 133:
! 134: teta *= Pi / 180.0;
! 135: cos_teta = cos(teta);
! 136: sin_teta = sin(teta);
! 137:
! 138: mat_unit(mat); /* Make it unit matrix. */
! 139: mat[0][0] = cos_teta;
! 140: mat[0][2] = -sin_teta;
! 141: mat[2][0] = sin_teta;
! 142: mat[2][2] = cos_teta;
! 143: }
! 144:
! 145: void mat_rot_z(teta, mat)
! 146: double teta;
! 147: transform_matrix mat;
! 148: {
! 149: double cos_teta, sin_teta;
! 150:
! 151: teta *= Pi / 180.0;
! 152: cos_teta = cos(teta);
! 153: sin_teta = sin(teta);
! 154:
! 155: mat_unit(mat); /* Make it unit matrix. */
! 156: mat[0][0] = cos_teta;
! 157: mat[0][1] = -sin_teta;
! 158: mat[1][0] = sin_teta;
! 159: mat[1][1] = cos_teta;
! 160: }
! 161:
! 162: /* Multiply two transform_matrix. Result can be one of two operands. */
! 163: void mat_mult(mat_res, mat1, mat2)
! 164: transform_matrix mat_res, mat1, mat2;
! 165: {
! 166: int i, j, k;
! 167: transform_matrix mat_res_temp;
! 168:
! 169: for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
! 170: mat_res_temp[i][j] = 0;
! 171: for (k = 0; k < 4; k++) mat_res_temp[i][j] += mat1[i][k] * mat2[k][j];
! 172: }
! 173: for (i = 0; i < 4; i++) for (j = 0; j < 4; j++)
! 174: mat_res[i][j] = mat_res_temp[i][j];
! 175: }
! 176:
! 177:
! 178: /* Test a single point to be within the xleft,xright,ybot,ytop bbox.
! 179: * Sets the returned integers 4 l.s.b. as follows:
! 180: * bit 0 if to the left of xleft.
! 181: * bit 1 if to the right of xright.
! 182: * bit 2 if above of ytop.
! 183: * bit 3 if below of ybot.
! 184: * 0 is returned if inside.
! 185: */
! 186: int clip_point(x, y)
! 187: unsigned int x, y;
! 188: {
! 189: int ret_val = 0;
! 190:
! 191: if (x < xleft) ret_val |= 0x01;
! 192: if (x > xright) ret_val |= 0x02;
! 193: if (y < ybot) ret_val |= 0x04;
! 194: if (y > ytop) ret_val |= 0x08;
! 195:
! 196: return ret_val;
! 197: }
! 198:
! 199: /* Clip the given line to drawing coords defined as xleft,xright,ybot,ytop.
! 200: * This routine uses the cohen & sutherland bit mapping for fast clipping -
! 201: * see "Principles of Interactive Computer Graphics" Newman & Sproull page 65.
! 202: */
! 203: void draw_clip_line(x1, y1, x2, y2)
! 204: unsigned int x1, y1, x2, y2;
! 205: {
! 206: int x, y, dx, dy, x_intr[4], y_intr[4], count, pos1, pos2;
! 207: register struct termentry *t = term;
! 208:
! 209: #if defined(ATARI) || defined(MTOS)
! 210: if(x1<0||x2<0||y1<0||y2<0) return; /* temp bug fix */
! 211: #endif
! 212:
! 213: pos1 = clip_point(x1, y1);
! 214: pos2 = clip_point(x2, y2);
! 215: if (pos1 || pos2) {
! 216: if (pos1 & pos2) return; /* segment is totally out. */
! 217:
! 218: /* Here part of the segment MAY be inside. test the intersection
! 219: * of this segment with the 4 boundaries for hopefully 2 intersections
! 220: * in. If none are found segment is totaly out.
! 221: * Under rare circumstances there may be up to 4 intersections (e.g.
! 222: * when the line passes directly through at least one corner). In
! 223: * this case it is sufficient to take any 2 intersections (e.g. the
! 224: * first two found).
! 225: */
! 226: count = 0;
! 227: dx = x2 - x1;
! 228: dy = y2 - y1;
! 229:
! 230: /* Find intersections with the x parallel bbox lines: */
! 231: if (dy != 0) {
! 232: x = (ybot - y2) * dx / dy + x2; /* Test for ybot boundary. */
! 233: if (x >= xleft && x <= xright) {
! 234: x_intr[count] = x;
! 235: y_intr[count++] = ybot;
! 236: }
! 237: x = (ytop - y2) * dx / dy + x2; /* Test for ytop boundary. */
! 238: if (x >= xleft && x <= xright) {
! 239: x_intr[count] = x;
! 240: y_intr[count++] = ytop;
! 241: }
! 242: }
! 243:
! 244: /* Find intersections with the y parallel bbox lines: */
! 245: if (dx != 0) {
! 246: y = (xleft - x2) * dy / dx + y2; /* Test for xleft boundary. */
! 247: if (y >= ybot && y <= ytop) {
! 248: x_intr[count] = xleft;
! 249: y_intr[count++] = y;
! 250: }
! 251: y = (xright - x2) * dy / dx + y2; /* Test for xright boundary. */
! 252: if (y >= ybot && y <= ytop) {
! 253: x_intr[count] = xright;
! 254: y_intr[count++] = y;
! 255: }
! 256: }
! 257:
! 258: if (count >= 2) {
! 259: int x_max, x_min, y_max, y_min;
! 260:
! 261: x_min = GPMIN(x1, x2);
! 262: x_max = GPMAX(x1, x2);
! 263: y_min = GPMIN(y1, y2);
! 264: y_max = GPMAX(y1, y2);
! 265:
! 266: if (pos1 && pos2) { /* Both were out - update both */
! 267: x1 = x_intr[0];
! 268: y1 = y_intr[0];
! 269: x2 = x_intr[1];
! 270: y2 = y_intr[1];
! 271: }
! 272: else if (pos1) { /* Only x1/y1 was out - update only it */
! 273: if (dx * (x2 - x_intr[0]) + dy * (y2 - y_intr[0]) > 0) {
! 274: x1 = x_intr[0];
! 275: y1 = y_intr[0];
! 276: }
! 277: else {
! 278: x1 = x_intr[1];
! 279: y1 = y_intr[1];
! 280: }
! 281: }
! 282: else { /* Only x2/y2 was out - update only it */
! 283: if (dx * (x_intr[0] - x1) + dy * (y_intr[0] - y1) > 0) {
! 284: x2 = x_intr[0];
! 285: y2 = y_intr[0];
! 286: }
! 287: else {
! 288: x2 = x_intr[1];
! 289: y2 = y_intr[1];
! 290: }
! 291: }
! 292:
! 293: if (x1 < x_min || x1 > x_max ||
! 294: x2 < x_min || x2 > x_max ||
! 295: y1 < y_min || y1 > y_max ||
! 296: y2 < y_min || y2 > y_max) return;
! 297: }
! 298: else
! 299: return;
! 300: }
! 301:
! 302:
! 303: #ifndef LITE
! 304: if(hidden3d && hidden_active && draw_surface)
! 305: {
! 306: draw_line_hidden(x1, y1, x2, y2);
! 307: return;
! 308: };
! 309: #endif /* not LITE */
! 310: if(!suppressMove) (*t->move)(x1,y1);
! 311: (*t->vector)(x2,y2);
! 312: }
! 313:
! 314:
! 315:
! 316: /* And text clipping routine. */
! 317: void clip_put_text(x, y, str)
! 318: unsigned int x,y;
! 319: char *str;
! 320: {
! 321: register struct termentry *t = term;
! 322:
! 323: if (clip_point(x, y)) return;
! 324:
! 325: (*t->put_text)(x,y,str);
! 326: }
! 327:
! 328: /* seems sensible to put the justification in here too..? */
! 329: void clip_put_text_just(x,y,str,just)
! 330: unsigned int x,y;
! 331: char *str;
! 332: enum JUSTIFY just;
! 333: {
! 334: register struct termentry *t = term;
! 335: if (clip_point(x,y)) return;
! 336: if (!(*t->justify_text)(just)) {
! 337: assert(CENTRE == 1 && RIGHT == 2);
! 338: x -= (t->h_char * strlen(str) * just)/2;
! 339: }
! 340: (*t->put_text)(x,y,str);
! 341: }
! 342:
! 343:
! 344:
! 345: /* Clip the given line to drawing coords defined as xleft,xright,ybot,ytop.
! 346: * This routine uses the cohen & sutherland bit mapping for fast clipping -
! 347: * see "Principles of Interactive Computer Graphics" Newman & Sproull page 65.
! 348: */
! 349:
! 350: int clip_line(x1, y1, x2, y2)
! 351: int *x1, *y1, *x2, *y2;
! 352: {
! 353: int x, y, dx, dy, x_intr[4], y_intr[4], count, pos1, pos2;
! 354: int x_max, x_min, y_max, y_min;
! 355: pos1 = clip_point(*x1, *y1);
! 356: pos2 = clip_point(*x2, *y2);
! 357: if (!pos1 && !pos2) return 1; /* segment is totally in */
! 358: if (pos1 & pos2) return 0; /* segment is totally out. */
! 359: /* Here part of the segment MAY be inside. test the intersection
! 360: * of this segment with the 4 boundaries for hopefully 2 intersections
! 361: * in. If non found segment is totaly out.
! 362: */
! 363: count = 0;
! 364: dx = *x2 - *x1;
! 365: dy = *y2 - *y1;
! 366: /* Find intersections with the x parallel bbox lines: */
! 367: if (dy != 0) {
! 368: x = (ybot - *y2) * dx / dy + *x2; /* Test for ybot boundary. */
! 369: if (x >= xleft && x <= xright) {
! 370: x_intr[count] = x;
! 371: y_intr[count++] = ybot;
! 372: }
! 373: x = (ytop - *y2) * dx / dy + *x2; /* Test for ytop boundary. */
! 374: if (x >= xleft && x <= xright) {
! 375: x_intr[count] = x;
! 376: y_intr[count++] = ytop;
! 377: }
! 378: }
! 379: /* Find intersections with the y parallel bbox lines: */
! 380: if (dx != 0) {
! 381: y = (xleft - *x2) * dy / dx + *y2; /* Test for xleft boundary. */
! 382: if (y >= ybot && y <= ytop) {
! 383: x_intr[count] = xleft;
! 384: y_intr[count++] = y;
! 385: }
! 386: y = (xright - *x2) * dy / dx + *y2; /* Test for xright boundary. */
! 387: if (y >= ybot && y <= ytop) {
! 388: x_intr[count] = xright;
! 389: y_intr[count++] = y;
! 390: }
! 391: }
! 392: if (count < 2) return 0;
! 393: if (*x1 < *x2)
! 394: x_min = *x1, x_max = *x2;
! 395: else
! 396: x_min = *x2, x_max = *x1;
! 397: if (*y1 < *y2)
! 398: y_min = *y1, y_max = *y2;
! 399: else
! 400: y_min = *y2, y_max = *y1;
! 401: if (pos1 && pos2) { /* Both were out - update both */
! 402: *x1 = x_intr[0];
! 403: *y1 = y_intr[0];
! 404: *x2 = x_intr[1];
! 405: *y2 = y_intr[1];
! 406: }
! 407: else if (pos1)
! 408: { /* Only x1/y1 was out - update only it */
! 409: if (dx * (*x2 - x_intr[0]) + dy * (*y2 - y_intr[0]) >= 0)
! 410: {
! 411: *x1 = x_intr[0];
! 412: *y1 = y_intr[0];
! 413: }
! 414: else
! 415: {
! 416: *x1 = x_intr[1];
! 417: *y1 = y_intr[1];
! 418: }
! 419: }
! 420: else
! 421: { /* Only x2/y2 was out - update only it */
! 422: if (dx * (x_intr[0] - *x1) + dy * (y_intr[0] - *y1) >= 0)
! 423: {
! 424: *x2 = x_intr[0];
! 425: *y2 = y_intr[0];
! 426: }
! 427: else
! 428: {
! 429: *x2 = x_intr[1];
! 430: *y2 = y_intr[1];
! 431: }
! 432: }
! 433:
! 434: if (*x1 < x_min || *x1 > x_max ||
! 435: *x2 < x_min || *x2 > x_max ||
! 436: *y1 < y_min || *y1 > y_max ||
! 437: *y2 < y_min || *y2 > y_max)
! 438: return 0;
! 439: return 1;
! 440: }
! 441:
! 442:
! 443: /* single edge intersection algorithm */
! 444: /* Given two points, one inside and one outside the plot, return
! 445: * the point where an edge of the plot intersects the line segment defined
! 446: * by the two points.
! 447: */
! 448: void edge3d_intersect(points, i, ex, ey, ez)
! 449: struct coordinate GPHUGE *points; /* the points array */
! 450: int i; /* line segment from point i-1 to point i */
! 451: double *ex, *ey, *ez; /* the point where it crosses an edge */
! 452: {
! 453: /* global x_min3d, x_max3d, y_min3d, y_max3d, min3d_z, max3d_z */
! 454: int count;
! 455: double ix = points[i-1].x;
! 456: double iy = points[i-1].y;
! 457: double iz = points[i-1].z;
! 458: double ox = points[i].x;
! 459: double oy = points[i].y;
! 460: double oz = points[i].z;
! 461: double x, y, z; /* possible intersection point */
! 462:
! 463: if(points[i].type == INRANGE)
! 464: {
! 465: /* swap points around so that ix/ix/iz are INRANGE and ox/oy/oz are OUTRANGE */
! 466: x = ix;ix = ox;ox = x;
! 467: y = iy;iy = oy;oy = y;
! 468: z = iz;iz = oz;oz = z;
! 469: }
! 470:
! 471: /* nasty degenerate cases, effectively drawing to an infinity point (?)
! 472: cope with them here, so don't process them as a "real" OUTRANGE point
! 473:
! 474: If more than one coord is -VERYLARGE, then can't ratio the "infinities"
! 475: so drop out by returning the INRANGE point.
! 476:
! 477: Obviously, only need to test the OUTRANGE point (coordinates) */
! 478:
! 479: /* nasty degenerate cases, effectively drawing to an infinity point (?)
! 480: cope with them here, so don't process them as a "real" OUTRANGE point
! 481:
! 482: If more than one coord is -VERYLARGE, then can't ratio the "infinities"
! 483: so drop out by returning FALSE */
! 484:
! 485: count = 0;
! 486: if(ox == -VERYLARGE) count++;
! 487: if(oy == -VERYLARGE) count++;
! 488: if(oz == -VERYLARGE) count++;
! 489:
! 490: /* either doesn't pass through 3D volume *or*
! 491: can't ratio infinities to get a direction to draw line, so return the INRANGE point */
! 492: if(count > 1){
! 493: *ex = ix;
! 494: *ey = iy;
! 495: *ez = iz;
! 496:
! 497: return;
! 498: }
! 499:
! 500: if(count == 1)
! 501: {
! 502: *ex = ix;
! 503: *ey = iy;
! 504: *ez = iz;
! 505:
! 506: if(ox == -VERYLARGE)
! 507: {
! 508: *ex = x_min3d;
! 509: return;
! 510: }
! 511:
! 512: if(oy == -VERYLARGE)
! 513: {
! 514: *ey = y_min3d;
! 515: return;
! 516: }
! 517:
! 518: /* obviously oz is -VERYLARGE and (ox != -VERYLARGE && oy != -VERYLARGE) */
! 519: *ez = min3d_z;
! 520: return;
! 521: }
! 522:
! 523: /*
! 524: * Can't have case (ix == ox && iy == oy && iz == oz) as one point
! 525: * is INRANGE and one point is OUTRANGE.
! 526: */
! 527: if(ix == ox) {
! 528: if(iy == oy) {
! 529: /* line parallel to z axis */
! 530:
! 531: /* assume inrange(iy, y_min3d, y_max3d) && inrange(ix, x_min3d, x_max3d) */
! 532: *ex = ix; /* == ox */
! 533: *ey = iy; /* == oy */
! 534:
! 535: if (inrange(max3d_z, iz, oz))
! 536: *ez = max3d_z;
! 537: else if (inrange(min3d_z, iz, oz))
! 538: *ez = min3d_z;
! 539: else {
! 540: graph_error("error in edge3d_intersect");
! 541: }
! 542:
! 543: return;
! 544: }
! 545:
! 546: if(iz == oz) {
! 547: /* line parallel to y axis */
! 548:
! 549: /* assume inrange(iz, min3d_z, max3d_z) && inrange(ix, x_min3d, x_max3d) */
! 550: *ex = ix; /* == ox */
! 551: *ez = iz; /* == oz */
! 552:
! 553: if (inrange(y_max3d, iy, oy))
! 554: *ey = y_max3d;
! 555: else if (inrange(y_min3d, iy, oy))
! 556: *ey = y_min3d;
! 557: else {
! 558: graph_error("error in edge3d_intersect");
! 559: }
! 560:
! 561: return;
! 562: }
! 563:
! 564: /* nasty 2D slanted line in a yz plane */
! 565:
! 566: /* does it intersect y_min3d edge */
! 567: if (inrange(y_min3d, iy, oy) && y_min3d != iy && y_min3d != oy) {
! 568: z = iz + (y_min3d-iy) * ((oz-iz) / (oy-iy));
! 569: if (inrange(z, min3d_z, max3d_z)) {
! 570: *ex = ix;
! 571: *ey = y_min3d;
! 572: *ez = z;
! 573: return;
! 574: }
! 575: }
! 576:
! 577: /* does it intersect y_max3d edge */
! 578: if (inrange(y_max3d, iy, oy) && y_max3d != iy && y_max3d != oy) {
! 579: z = iz + (y_max3d-iy) * ((oz-iz) / (oy-iy));
! 580: if (inrange(z, min3d_z, max3d_z)) {
! 581: *ex = ix;
! 582: *ey = y_max3d;
! 583: *ez = z;
! 584: return;
! 585: }
! 586: }
! 587:
! 588: /* does it intersect min3d_z edge */
! 589: if (inrange(min3d_z, iz, oz) && min3d_z != iz && min3d_z != oz) {
! 590: y = iy + (min3d_z-iz) * ((oy-iy) / (oz-iz));
! 591: if (inrange(y, y_min3d, y_max3d)) {
! 592: *ex = ix;
! 593: *ey = y;
! 594: *ez = min3d_z;
! 595: return;
! 596: }
! 597: }
! 598:
! 599: /* does it intersect max3d_z edge */
! 600: if (inrange(max3d_z, iz, oz) && max3d_z != iz && max3d_z != oz) {
! 601: y = iy + (max3d_z-iz) * ((oy-iy) / (oz-iz));
! 602: if (inrange(y, y_min3d, y_max3d)) {
! 603: *ex = ix;
! 604: *ey = y;
! 605: *ez = max3d_z;
! 606: return;
! 607: }
! 608: }
! 609: }
! 610:
! 611: if(iy == oy) {
! 612: /* already checked case (ix == ox && iy == oy) */
! 613: if(oz == iz) {
! 614: /* line parallel to x axis */
! 615:
! 616: /* assume inrange(iz, min3d_z, max3d_z) && inrange(iy, y_min3d, y_max3d) */
! 617: *ey = iy; /* == oy */
! 618: *ez = iz; /* == oz */
! 619:
! 620: if (inrange(x_max3d, ix, ox))
! 621: *ex = x_max3d;
! 622: else if (inrange(x_min3d, ix, ox))
! 623: *ex = x_min3d;
! 624: else {
! 625: graph_error("error in edge3d_intersect");
! 626: }
! 627:
! 628: return;
! 629: }
! 630:
! 631: /* nasty 2D slanted line in an xz plane */
! 632:
! 633: /* does it intersect x_min3d edge */
! 634: if (inrange(x_min3d, ix, ox) && x_min3d != ix && x_min3d != ox) {
! 635: z = iz + (x_min3d-ix) * ((oz-iz) / (ox-ix));
! 636: if (inrange(z, min3d_z, max3d_z)) {
! 637: *ex = x_min3d;
! 638: *ey = iy;
! 639: *ez = z;
! 640: return;
! 641: }
! 642: }
! 643:
! 644: /* does it intersect x_max3d edge */
! 645: if (inrange(x_max3d, ix, ox) && x_max3d != ix && x_max3d != ox) {
! 646: z = iz + (x_max3d-ix) * ((oz-iz) / (ox-ix));
! 647: if (inrange(z, min3d_z, max3d_z)) {
! 648: *ex = x_max3d;
! 649: *ey = iy;
! 650: *ez = z;
! 651: return;
! 652: }
! 653: }
! 654:
! 655: /* does it intersect min3d_z edge */
! 656: if (inrange(min3d_z, iz, oz) && min3d_z != iz && min3d_z != oz) {
! 657: x = ix + (min3d_z-iz) * ((ox-ix) / (oz-iz));
! 658: if (inrange(x, x_min3d, x_max3d)) {
! 659: *ex = x;
! 660: *ey = iy;
! 661: *ez = min3d_z;
! 662: return;
! 663: }
! 664: }
! 665:
! 666: /* does it intersect max3d_z edge */
! 667: if (inrange(max3d_z, iz, oz) && max3d_z != iz && max3d_z != oz) {
! 668: x = ix + (max3d_z-iz) * ((ox-ix) / (oz-iz));
! 669: if (inrange(x, x_min3d, x_max3d)) {
! 670: *ex = x;
! 671: *ey = iy;
! 672: *ez = max3d_z;
! 673: return;
! 674: }
! 675: }
! 676: }
! 677:
! 678: if(iz == oz) {
! 679: /* already checked cases (ix == ox && iz == oz) and (iy == oy && iz == oz) */
! 680:
! 681: /* nasty 2D slanted line in an xy plane */
! 682:
! 683: /* assume inrange(oz, min3d_z, max3d_z) */
! 684:
! 685: /* does it intersect x_min3d edge */
! 686: if (inrange(x_min3d, ix, ox) && x_min3d != ix && x_min3d != ox) {
! 687: y = iy + (x_min3d-ix) * ((oy-iy) / (ox-ix));
! 688: if (inrange(y, y_min3d, y_max3d)) {
! 689: *ex = x_min3d;
! 690: *ey = y;
! 691: *ez = iz;
! 692: return;
! 693: }
! 694: }
! 695:
! 696: /* does it intersect x_max3d edge */
! 697: if (inrange(x_max3d, ix, ox) && x_max3d != ix && x_max3d != ox) {
! 698: y = iy + (x_max3d-ix) * ((oy-iy) / (ox-ix));
! 699: if (inrange(y, y_min3d, y_max3d)) {
! 700: *ex = x_max3d;
! 701: *ey = y;
! 702: *ez = iz;
! 703: return;
! 704: }
! 705: }
! 706:
! 707: /* does it intersect y_min3d edge */
! 708: if (inrange(y_min3d, iy, oy) && y_min3d != iy && y_min3d != oy) {
! 709: x = ix + (y_min3d-iy) * ((ox-ix) / (oy-iy));
! 710: if (inrange(x, x_min3d, x_max3d)) {
! 711: *ex = x;
! 712: *ey = y_min3d;
! 713: *ez = iz;
! 714: return;
! 715: }
! 716: }
! 717:
! 718: /* does it intersect y_max3d edge */
! 719: if (inrange(y_max3d, iy, oy) && y_max3d != iy && y_max3d != oy) {
! 720: x = ix + (y_max3d-iy) * ((ox-ix) / (oy-iy));
! 721: if (inrange(x, x_min3d, x_max3d)) {
! 722: *ex = x;
! 723: *ey = y_max3d;
! 724: *ez = iz;
! 725: return;
! 726: }
! 727: }
! 728: }
! 729:
! 730: /* really nasty general slanted 3D case */
! 731:
! 732: /* does it intersect x_min3d edge */
! 733: if (inrange(x_min3d, ix, ox) && x_min3d != ix && x_min3d != ox) {
! 734: y = iy + (x_min3d-ix) * ((oy-iy) / (ox-ix));
! 735: z = iz + (x_min3d-ix) * ((oz-iz) / (ox-ix));
! 736: if (inrange(y, y_min3d, y_max3d) && inrange(z, min3d_z, max3d_z)) {
! 737: *ex = x_min3d;
! 738: *ey = y;
! 739: *ez = z;
! 740: return;
! 741: }
! 742: }
! 743:
! 744: /* does it intersect x_max3d edge */
! 745: if (inrange(x_max3d, ix, ox) && x_max3d != ix && x_max3d != ox) {
! 746: y = iy + (x_max3d-ix) * ((oy-iy) / (ox-ix));
! 747: z = iz + (x_max3d-ix) * ((oz-iz) / (ox-ix));
! 748: if (inrange(y, y_min3d, y_max3d) && inrange(z, min3d_z, max3d_z)) {
! 749: *ex = x_max3d;
! 750: *ey = y;
! 751: *ez = z;
! 752: return;
! 753: }
! 754: }
! 755:
! 756: /* does it intersect y_min3d edge */
! 757: if (inrange(y_min3d, iy, oy) && y_min3d != iy && y_min3d != oy) {
! 758: x = ix + (y_min3d-iy) * ((ox-ix) / (oy-iy));
! 759: z = iz + (y_min3d-iy) * ((oz-iz) / (oy-iy));
! 760: if (inrange(x, x_min3d, x_max3d) && inrange(z, min3d_z, max3d_z)) {
! 761: *ex = x;
! 762: *ey = y_min3d;
! 763: *ez = z;
! 764: return;
! 765: }
! 766: }
! 767:
! 768: /* does it intersect y_max3d edge */
! 769: if (inrange(y_max3d, iy, oy) && y_max3d != iy && y_max3d != oy) {
! 770: x = ix + (y_max3d-iy) * ((ox-ix) / (oy-iy));
! 771: z = iz + (y_max3d-iy) * ((oz-iz) / (oy-iy));
! 772: if (inrange(x, x_min3d, x_max3d) && inrange(z, min3d_z, max3d_z)) {
! 773: *ex = x;
! 774: *ey = y_max3d;
! 775: *ez = z;
! 776: return;
! 777: }
! 778: }
! 779:
! 780: /* does it intersect min3d_z edge */
! 781: if (inrange(min3d_z, iz, oz) && min3d_z != iz && min3d_z != oz) {
! 782: x = ix + (min3d_z-iz) * ((ox-ix) / (oz-iz));
! 783: y = iy + (min3d_z-iz) * ((oy-iy) / (oz-iz));
! 784: if (inrange(x, x_min3d, x_max3d) && inrange(y, y_min3d, y_max3d)) {
! 785: *ex = x;
! 786: *ey = y;
! 787: *ez = min3d_z;
! 788: return;
! 789: }
! 790: }
! 791:
! 792: /* does it intersect max3d_z edge */
! 793: if (inrange(max3d_z, iz, oz) && max3d_z != iz && max3d_z != oz) {
! 794: x = ix + (max3d_z-iz) * ((ox-ix) / (oz-iz));
! 795: y = iy + (max3d_z-iz) * ((oy-iy) / (oz-iz));
! 796: if (inrange(x, x_min3d, x_max3d) && inrange(y, y_min3d, y_max3d)) {
! 797: *ex = x;
! 798: *ey = y;
! 799: *ez = max3d_z;
! 800: return;
! 801: }
! 802: }
! 803:
! 804: /* If we reach here, the inrange point is on the edge, and
! 805: * the line segment from the outrange point does not cross any
! 806: * other edges to get there. In this case, we return the inrange
! 807: * point as the 'edge' intersection point. This will basically draw
! 808: * line.
! 809: */
! 810: *ex = ix;
! 811: *ey = iy;
! 812: *ez = iz;
! 813: return;
! 814: }
! 815:
! 816: /* double edge intersection algorithm */
! 817: /* Given two points, both outside the plot, return
! 818: * the points where an edge of the plot intersects the line segment defined
! 819: * by the two points. There may be zero, one, two, or an infinite number
! 820: * of intersection points. (One means an intersection at a corner, infinite
! 821: * means overlaying the edge itself). We return FALSE when there is nothing
! 822: * to draw (zero intersections), and TRUE when there is something to
! 823: * draw (the one-point case is a degenerate of the two-point case and we do
! 824: * not distinguish it - we draw it anyway).
! 825: */
! 826: TBOOLEAN /* any intersection? */
! 827: two_edge3d_intersect(points, i, lx, ly, lz)
! 828: struct coordinate GPHUGE *points; /* the points array */
! 829: int i; /* line segment from point i-1 to point i */
! 830: double *lx, *ly, *lz; /* lx[2], ly[2], lz[2]: points where it crosses edges */
! 831: {
! 832: int count;
! 833: /* global x_min3d, x_max3d, y_min3d, y_max3d, min3d_z, max3d_z */
! 834: double ix = points[i-1].x;
! 835: double iy = points[i-1].y;
! 836: double iz = points[i-1].z;
! 837: double ox = points[i].x;
! 838: double oy = points[i].y;
! 839: double oz = points[i].z;
! 840: double t[6];
! 841: double swap;
! 842: double x, y, z; /* possible intersection point */
! 843: double t_min, t_max;
! 844:
! 845: /* nasty degenerate cases, effectively drawing to an infinity point (?)
! 846: cope with them here, so don't process them as a "real" OUTRANGE point
! 847:
! 848: If more than one coord is -VERYLARGE, then can't ratio the "infinities"
! 849: so drop out by returning FALSE */
! 850:
! 851: count = 0;
! 852: if(ix == -VERYLARGE) count++;
! 853: if(ox == -VERYLARGE) count++;
! 854: if(iy == -VERYLARGE) count++;
! 855: if(oy == -VERYLARGE) count++;
! 856: if(iz == -VERYLARGE) count++;
! 857: if(oz == -VERYLARGE) count++;
! 858:
! 859: /* either doesn't pass through 3D volume *or*
! 860: can't ratio infinities to get a direction to draw line, so simply return(FALSE) */
! 861: if(count > 1){
! 862: return(FALSE);
! 863: }
! 864:
! 865: if(ox == -VERYLARGE || ix == -VERYLARGE)
! 866: {
! 867: if(ix == -VERYLARGE)
! 868: {
! 869: /* swap points so ix/iy/iz don't have a -VERYLARGE component */
! 870: x = ix;ix = ox;ox = x;
! 871: y = iy;iy = oy;oy = y;
! 872: z = iz;iz = oz;oz = z;
! 873: }
! 874:
! 875: /* check actually passes through the 3D graph volume */
! 876: if(ix > x_max3d && inrange(iy, y_min3d, y_max3d) && inrange(iz, min3d_z, max3d_z))
! 877: {
! 878: lx[0] = x_min3d;
! 879: ly[0] = iy;
! 880: lz[0] = iz;
! 881:
! 882: lx[1] = x_max3d;
! 883: ly[1] = iy;
! 884: lz[1] = iz;
! 885:
! 886: return(TRUE);
! 887: }
! 888: else {
! 889: return(FALSE);
! 890: }
! 891: }
! 892:
! 893: if(oy == -VERYLARGE || iy == -VERYLARGE)
! 894: {
! 895: if(iy == -VERYLARGE)
! 896: {
! 897: /* swap points so ix/iy/iz don't have a -VERYLARGE component */
! 898: x = ix; ix = ox; ox = x;
! 899: y = iy; iy = oy; oy = y;
! 900: z = iz; iz = oz; oz = z;
! 901: }
! 902:
! 903: /* check actually passes through the 3D graph volume */
! 904: if(iy > y_max3d && inrange(ix, x_min3d, x_max3d) && inrange(iz, min3d_z, max3d_z))
! 905: {
! 906: lx[0] = ix;
! 907: ly[0] = y_min3d;
! 908: lz[0] = iz;
! 909:
! 910: lx[1] = ix;
! 911: ly[1] = y_max3d;
! 912: lz[1] = iz;
! 913:
! 914: return(TRUE);
! 915: }
! 916: else {
! 917: return(FALSE);
! 918: }
! 919: }
! 920:
! 921: if(oz == -VERYLARGE || iz == -VERYLARGE)
! 922: {
! 923: if(iz == -VERYLARGE)
! 924: {
! 925: /* swap points so ix/iy/iz don't have a -VERYLARGE component */
! 926: x = ix; ix = ox; ox = x;
! 927: y = iy; iy = oy; oy = y;
! 928: z = iz; iz = oz; oz = z;
! 929: }
! 930:
! 931: /* check actually passes through the 3D graph volume */
! 932: if(iz > max3d_z && inrange(ix, x_min3d, x_max3d) && inrange(iy, y_min3d, y_max3d))
! 933: {
! 934: lx[0] = ix;
! 935: ly[0] = iy;
! 936: lz[0] = min3d_z;
! 937:
! 938: lx[1] = ix;
! 939: ly[1] = iy;
! 940: lz[1] = max3d_z;
! 941:
! 942: return(TRUE);
! 943: }
! 944: else {
! 945: return(FALSE);
! 946: }
! 947: }
! 948:
! 949: /*
! 950: * Quick outcode tests on the 3d graph volume
! 951: */
! 952:
! 953: /*
! 954: * test z coord first --- most surface OUTRANGE points generated between
! 955: * min3d_z and z_min3d (i.e. when ticslevel is non-zero)
! 956: */
! 957: if(GPMAX(iz,oz) < min3d_z || GPMIN(iz,oz) > max3d_z)
! 958: return(FALSE);
! 959:
! 960: if(GPMAX(ix,ox) < x_min3d || GPMIN(ix,ox) > x_max3d)
! 961: return(FALSE);
! 962:
! 963: if(GPMAX(iy,oy) < y_min3d || GPMIN(iy,oy) > y_max3d)
! 964: return(FALSE);
! 965:
! 966: /*
! 967: * Special horizontal/vertical, etc. cases are checked and remaining
! 968: * slant lines are checked separately.
! 969: *
! 970: * The slant line intersections are solved using the parametric form
! 971: * of the equation for a line, since if we test x/y/z min/max planes explicitly
! 972: * then e.g. a line passing through a corner point (x_min,y_min,z_min)
! 973: * actually intersects all 3 planes and hence further tests would be required
! 974: * to anticipate this and similar situations.
! 975: */
! 976:
! 977: /*
! 978: * Can have case (ix == ox && iy == oy && iz == oz) as both points OUTRANGE
! 979: */
! 980: if(ix == ox && iy == oy && iz == oz)
! 981: {
! 982: /* but as only define single outrange point, can't intersect 3D graph volume */
! 983: return(FALSE);
! 984: }
! 985:
! 986: if(ix == ox) {
! 987: if(iy == oy) {
! 988: /* line parallel to z axis */
! 989:
! 990: /* x and y coords must be in range, and line must span both min3d_z and max3d_z */
! 991: /* note that spanning min3d_z implies spanning max3d_z as both points OUTRANGE */
! 992: if(!inrange(ix, x_min3d, x_max3d) || !inrange(iy, y_min3d, y_max3d))
! 993: {
! 994: return(FALSE);
! 995: }
! 996:
! 997: if (inrange(min3d_z, iz, oz)) {
! 998: lx[0] = ix;
! 999: ly[0] = iy;
! 1000: lz[0] = min3d_z;
! 1001:
! 1002: lx[1] = ix;
! 1003: ly[1] = iy;
! 1004: lz[1] = max3d_z;
! 1005:
! 1006: return(TRUE);
! 1007: } else
! 1008: return(FALSE);
! 1009: }
! 1010:
! 1011: if(iz == oz) {
! 1012: /* line parallel to y axis */
! 1013:
! 1014: /* x and z coords must be in range, and line must span both y_min3d and y_max3d */
! 1015: /* note that spanning y_min3d implies spanning y_max3d, as both points OUTRANGE */
! 1016: if(!inrange(ix, x_min3d, x_max3d) || !inrange(iz, min3d_z, max3d_z))
! 1017: {
! 1018: return(FALSE);
! 1019: }
! 1020:
! 1021: if (inrange(y_min3d, iy, oy)) {
! 1022: lx[0] = ix;
! 1023: ly[0] = y_min3d;
! 1024: lz[0] = iz;
! 1025:
! 1026: lx[1] = ix;
! 1027: ly[1] = y_max3d;
! 1028: lz[1] = iz;
! 1029:
! 1030: return(TRUE);
! 1031: } else
! 1032: return(FALSE);
! 1033: }
! 1034:
! 1035: /* nasty 2D slanted line in a yz plane */
! 1036:
! 1037: if(!inrange(ox, x_min3d, x_max3d))
! 1038: return(FALSE);
! 1039:
! 1040: t[0] = (y_min3d - iy)/(oy - iy);
! 1041: t[1] = (y_max3d - iy)/(oy - iy);
! 1042:
! 1043: if(t[0] > t[1]) {
! 1044: swap = t[0];t[0] = t[1];t[1] = swap;
! 1045: }
! 1046:
! 1047: t[2] = (min3d_z - iz)/(oz - iz);
! 1048: t[3] = (max3d_z - iz)/(oz - iz);
! 1049:
! 1050: if(t[2] > t[3]) {
! 1051: swap = t[2];t[2] = t[3];t[3] = swap;
! 1052: }
! 1053:
! 1054: t_min = GPMAX(GPMAX(t[0],t[2]),0.0);
! 1055: t_max = GPMIN(GPMIN(t[1],t[3]),1.0);
! 1056:
! 1057: if(t_min > t_max)
! 1058: return(FALSE);
! 1059:
! 1060: lx[0] = ix;
! 1061: ly[0] = iy + t_min * (oy - iy);
! 1062: lz[0] = iz + t_min * (oz - iz);
! 1063:
! 1064: lx[1] = ix;
! 1065: ly[1] = iy + t_max * (oy - iy);
! 1066: lz[1] = iz + t_max * (oz - iz);
! 1067:
! 1068: /*
! 1069: * Can only have 0 or 2 intersection points -- only need test one coord
! 1070: */
! 1071: if(inrange(ly[0], y_min3d, y_max3d) &&
! 1072: inrange(lz[0], min3d_z, max3d_z))
! 1073: {
! 1074: return(TRUE);
! 1075: }
! 1076:
! 1077: return(FALSE);
! 1078: }
! 1079:
! 1080: if(iy == oy) {
! 1081: /* already checked case (ix == ox && iy == oy) */
! 1082: if(oz == iz) {
! 1083: /* line parallel to x axis */
! 1084:
! 1085: /* y and z coords must be in range, and line must span both x_min3d and x_max3d */
! 1086: /* note that spanning x_min3d implies spanning x_max3d, as both points OUTRANGE */
! 1087: if(!inrange(iy, y_min3d, y_max3d) || !inrange(iz, min3d_z, max3d_z))
! 1088: {
! 1089: return(FALSE);
! 1090: }
! 1091:
! 1092: if (inrange(x_min3d, ix, ox)) {
! 1093: lx[0] = x_min3d;
! 1094: ly[0] = iy;
! 1095: lz[0] = iz;
! 1096:
! 1097: lx[1] = x_max3d;
! 1098: ly[1] = iy;
! 1099: lz[1] = iz;
! 1100:
! 1101: return(TRUE);
! 1102: } else
! 1103: return(FALSE);
! 1104: }
! 1105:
! 1106: /* nasty 2D slanted line in an xz plane */
! 1107:
! 1108: if(!inrange(oy, y_min3d, y_max3d))
! 1109: return(FALSE);
! 1110:
! 1111: t[0] = (x_min3d - ix)/(ox - ix);
! 1112: t[1] = (x_max3d - ix)/(ox - ix);
! 1113:
! 1114: if(t[0] > t[1]) {
! 1115: swap = t[0];t[0] = t[1];t[1] = swap;
! 1116: }
! 1117:
! 1118: t[2] = (min3d_z - iz)/(oz - iz);
! 1119: t[3] = (max3d_z - iz)/(oz - iz);
! 1120:
! 1121: if(t[2] > t[3]) {
! 1122: swap = t[2];t[2] = t[3];t[3] = swap;
! 1123: }
! 1124:
! 1125: t_min = GPMAX(GPMAX(t[0],t[2]),0.0);
! 1126: t_max = GPMIN(GPMIN(t[1],t[3]),1.0);
! 1127:
! 1128: if(t_min > t_max)
! 1129: return(FALSE);
! 1130:
! 1131: lx[0] = ix + t_min * (ox - ix);
! 1132: ly[0] = iy;
! 1133: lz[0] = iz + t_min * (oz - iz);
! 1134:
! 1135: lx[1] = ix + t_max * (ox - ix);
! 1136: ly[1] = iy;
! 1137: lz[1] = iz + t_max * (oz - iz);
! 1138:
! 1139: /*
! 1140: * Can only have 0 or 2 intersection points -- only need test one coord
! 1141: */
! 1142: if(inrange(lx[0], x_min3d, x_max3d) &&
! 1143: inrange(lz[0], min3d_z, max3d_z))
! 1144: {
! 1145: return(TRUE);
! 1146: }
! 1147:
! 1148: return(FALSE);
! 1149: }
! 1150:
! 1151: if(iz == oz) {
! 1152: /* already checked cases (ix == ox && iz == oz) and (iy == oy && iz == oz) */
! 1153:
! 1154: /* nasty 2D slanted line in an xy plane */
! 1155:
! 1156: if(!inrange(oz, min3d_z, max3d_z))
! 1157: return(FALSE);
! 1158:
! 1159: t[0] = (x_min3d - ix)/(ox - ix);
! 1160: t[1] = (x_max3d - ix)/(ox - ix);
! 1161:
! 1162: if(t[0] > t[1]) {
! 1163: swap = t[0];t[0] = t[1];t[1] = swap;
! 1164: }
! 1165:
! 1166: t[2] = (y_min3d - iy)/(oy - iy);
! 1167: t[3] = (y_max3d - iy)/(oy - iy);
! 1168:
! 1169: if(t[2] > t[3]) {
! 1170: swap = t[2];t[2] = t[3];t[3] = swap;
! 1171: }
! 1172:
! 1173: t_min = GPMAX(GPMAX(t[0],t[2]),0.0);
! 1174: t_max = GPMIN(GPMIN(t[1],t[3]),1.0);
! 1175:
! 1176: if(t_min > t_max)
! 1177: return(FALSE);
! 1178:
! 1179: lx[0] = ix + t_min * (ox - ix);
! 1180: ly[0] = iy + t_min * (oy - iy);
! 1181: lz[0] = iz;
! 1182:
! 1183: lx[1] = ix + t_max * (ox - ix);
! 1184: ly[1] = iy + t_max * (oy - iy);
! 1185: lz[1] = iz;
! 1186:
! 1187: /*
! 1188: * Can only have 0 or 2 intersection points -- only need test one coord
! 1189: */
! 1190: if(inrange(lx[0], x_min3d, x_max3d) &&
! 1191: inrange(ly[0], y_min3d, y_max3d))
! 1192: {
! 1193: return(TRUE);
! 1194: }
! 1195:
! 1196: return(FALSE);
! 1197: }
! 1198:
! 1199: /* really nasty general slanted 3D case */
! 1200:
! 1201: /*
! 1202: Solve parametric equation
! 1203:
! 1204: (ix, iy, iz) + t (diff_x, diff_y, diff_z)
! 1205:
! 1206: where 0.0 <= t <= 1.0 and
! 1207:
! 1208: diff_x = (ox - ix);
! 1209: diff_y = (oy - iy);
! 1210: diff_z = (oz - iz);
! 1211: */
! 1212:
! 1213: t[0] = (x_min3d - ix)/(ox - ix);
! 1214: t[1] = (x_max3d - ix)/(ox - ix);
! 1215:
! 1216: if(t[0] > t[1]) {
! 1217: swap = t[0];t[0] = t[1];t[1] = swap;
! 1218: }
! 1219:
! 1220: t[2] = (y_min3d - iy)/(oy - iy);
! 1221: t[3] = (y_max3d - iy)/(oy - iy);
! 1222:
! 1223: if(t[2] > t[3]) {
! 1224: swap = t[2];t[2] = t[3];t[3] = swap;
! 1225: }
! 1226:
! 1227: t[4] = (iz == oz) ? 0.0 : (min3d_z - iz)/(oz - iz);
! 1228: t[5] = (iz == oz) ? 1.0 : (max3d_z - iz)/(oz - iz);
! 1229:
! 1230: if(t[4] > t[5]) {
! 1231: swap = t[4];t[4] = t[5];t[5] = swap;
! 1232: }
! 1233:
! 1234: t_min = GPMAX(GPMAX(t[0],t[2]),GPMAX(t[4],0.0));
! 1235: t_max = GPMIN(GPMIN(t[1],t[3]),GPMIN(t[5],1.0));
! 1236:
! 1237: if(t_min > t_max)
! 1238: return(FALSE);
! 1239:
! 1240: lx[0] = ix + t_min * (ox - ix);
! 1241: ly[0] = iy + t_min * (oy - iy);
! 1242: lz[0] = iz + t_min * (oz - iz);
! 1243:
! 1244: lx[1] = ix + t_max * (ox - ix);
! 1245: ly[1] = iy + t_max * (oy - iy);
! 1246: lz[1] = iz + t_max * (oz - iz);
! 1247:
! 1248: /*
! 1249: * Can only have 0 or 2 intersection points -- only need test one coord
! 1250: */
! 1251: if(inrange(lx[0], x_min3d, x_max3d) &&
! 1252: inrange(ly[0], y_min3d, y_max3d) &&
! 1253: inrange(lz[0], min3d_z, max3d_z))
! 1254: {
! 1255: return(TRUE);
! 1256: }
! 1257:
! 1258: return(FALSE);
! 1259: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util3d.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot