Annotation of OpenXM_contrib/gnuplot/util3d.c, Revision 1.1.1.3
1.1 maekawa 1: #ifndef lint
1.1.1.3 ! ohara 2: static char *RCSid = "$Id: util3d.c,v 1.7.2.1 2002/03/11 16:09:00 lhecking Exp $";
1.1 maekawa 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:
1.1.1.3 ! ohara 117: teta *= M_PI / 180.0;
1.1 maekawa 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:
1.1.1.3 ! ohara 134: teta *= M_PI / 180.0;
1.1 maekawa 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:
1.1.1.3 ! ohara 151: teta *= M_PI / 180.0;
1.1 maekawa 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