home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / gnuplot3 / patch02f / patch.3
Encoding:
Text File  |  1992-06-19  |  27.9 KB  |  1,021 lines
  1. diff -rc gnuplot/graph3d.c gnuplot3.2/graph3d.c
  2. *** gnuplot/graph3d.c    Fri Sep 20 09:36:52 1991
  3. --- gnuplot3.2/graph3d.c    Wed Mar 25 07:59:40 1992
  4. ***************
  5. *** 1,6 ****
  6.   /* GNUPLOT - graph3d.c */
  7.   /*
  8. !  * Copyright (C) 1986, 1987, 1990, 1991   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. --- 1,10 ----
  13. + #ifndef lint
  14. + static char *RCSid = "$Id: graph3d.c,v 3.26 92/03/24 22:34:27 woo Exp Locker: woo $";
  15. + #endif
  16. + 
  17.   /* GNUPLOT - graph3d.c */
  18.   /*
  19. !  * Copyright (C) 1986, 1987, 1990, 1991, 1992   Thomas Williams, Colin Kelley
  20.    *
  21.    * Permission to use, copy, and distribute this software and its
  22.    * documentation for any purpose with or without fee is hereby granted, 
  23. ***************
  24. *** 21,31 ****
  25.    *       Gershon Elber and many others.
  26.    *
  27.    * Send your comments or suggestions to 
  28. !  *  pixar!info-gnuplot@sun.com.
  29.    * This is a mailing list; to join it send a note to 
  30. !  *  pixar!info-gnuplot-request@sun.com.  
  31.    * Send bug reports to
  32. !  *  pixar!bug-gnuplot@sun.com.
  33.    */
  34.   
  35.   #include <stdio.h>
  36. --- 25,35 ----
  37.    *       Gershon Elber and many others.
  38.    *
  39.    * Send your comments or suggestions to 
  40. !  *  info-gnuplot@ames.arc.nasa.gov.
  41.    * This is a mailing list; to join it send a note to 
  42. !  *  info-gnuplot-request@ames.arc.nasa.gov.  
  43.    * Send bug reports to
  44. !  *  bug-gnuplot@ames.arc.nasa.gov.
  45.    */
  46.   
  47.   #include <stdio.h>
  48. ***************
  49. *** 46,51 ****
  50. --- 50,76 ----
  51.   #endif
  52.   #endif
  53.   
  54. + /*
  55. +  * hidden_line_type_above, hidden_line_type_below - controls type of lines
  56. +  *   for above and below parts of the surface.
  57. +  * hidden_no_update - if TRUE lines will be hidden line removed but they
  58. +  *   are not assumed to be part of the surface (i.e. grid) and therefore
  59. +  *   do not influence the hidings.
  60. +  * hidden_max_index - length of hidden_low_bound and hidden_high_bound vecs.
  61. +  * hidden_first_row - TRUE if we are now drawing the first row of the surface.
  62. +  * hidden_active - TRUE if hidden lines are to be removed.
  63. +  * hidden_low_bound, hidden_high_bound - two vectors of size hidden_max_index
  64. +  *   that hold the above and below floating horisons.
  65. +  */
  66. + static int hidden_line_type_above, hidden_line_type_below, hidden_no_update;
  67. + static int hidden_max_index, hidden_first_row, hidden_active = FALSE;
  68. + static int *hidden_low_bound, *hidden_high_bound;
  69. + #define HIDDEN_BOUND(x)        (x < 0 ? 0 : x >= hidden_max_index ? \
  70. +                              hidden_max_index - 1 : x)
  71. + #define HIDDEN_LOW_BOUND(x) (hidden_low_bound[HIDDEN_BOUND(x)])
  72. + #define HIDDEN_HIGH_BOUND(x) (hidden_high_bound[HIDDEN_BOUND(x)])
  73. + #define SET_HIDDEN_BOUND(vec, x, y) (vec[HIDDEN_BOUND(x)] = y)
  74. + 
  75.   static plot3d_impulses();
  76.   static plot3d_lines();
  77.   static plot3d_points();
  78. ***************
  79. *** 70,75 ****
  80. --- 95,101 ----
  81.   static xtick();
  82.   static ytick();
  83.   static ztick();
  84. + static setlinestyle();
  85.   
  86.   #ifndef max        /* Lattice C has max() in math.h, but shouldn't! */
  87.   #define max(a,b) ((a > b) ? a : b)
  88. ***************
  89. *** 243,248 ****
  90. --- 269,539 ----
  91.       *yt = ((int) (res[1] * yscaler / w)) + ymiddle;
  92.   }
  93.   
  94. + /* And the functions to map from user 3D space to terminal z coordinate */
  95. + static double map3d_z(x, y, z)
  96. + double x, y, z;
  97. + {
  98. +     int i;
  99. +     double v[4], res,                 /* Homogeneous coords. vectors. */
  100. +     w = trans_mat[3][3];
  101. + 
  102. +     v[0] = map_x3d(x); /* Normalize object space to -1..1 */
  103. +     v[1] = map_y3d(y);
  104. +     v[2] = map_z3d(z);
  105. +     v[3] = 1.0;
  106. + 
  107. +     res = trans_mat[3][2];               /* Initiate it with the weight factor. */
  108. +     for (i = 0; i < 3; i++) res += v[i] * trans_mat[i][2];
  109. + 
  110. +     return res;
  111. + }
  112. + 
  113. + /* Initialize the line style using the current device and set hidden styles  */
  114. + /* to it as well if hidden line removal is enabled.                 */
  115. + static setlinestyle(style)
  116. + int style;
  117. + {
  118. +     register struct termentry *t = &term_tbl[term];
  119. + 
  120. +     (*t->linetype)(style);
  121. +     if (hidden3d) {
  122. +     hidden_line_type_above = style;
  123. +     hidden_line_type_below = style;
  124. +     }
  125. + }
  126. + 
  127. + /* Initialize the necessary steps for hidden line removal. This algorithm    */
  128. + /* is based on the "floating horizon" explicit surfaces hidden line removal. */
  129. + static void init_hidden_line_removal()
  130. + {
  131. +     hidden_max_index = xright - xleft + 1;
  132. +     hidden_low_bound = (int *) alloc(sizeof(int) * hidden_max_index, "hidden");
  133. +     hidden_high_bound = (int *) alloc(sizeof(int) * hidden_max_index, "hidden");
  134. + }
  135. + 
  136. + /* Reset the hidden line data to a fresh start.                     */
  137. + static void reset_hidden_line_removal()
  138. + {
  139. +     int i;
  140. + 
  141. +     for (i = 0; i < hidden_max_index; i++) {
  142. +         hidden_low_bound[i] = ytop;
  143. +         hidden_high_bound[i] = ybot;
  144. +     }
  145. + }
  146. + 
  147. + /* Terminates the hidden line removal process. Free any memory allocated by  */
  148. + /* init_hidden_line_removal above.                         */
  149. + static void term_hidden_line_removal()
  150. + {
  151. +     free(hidden_low_bound);
  152. +     free(hidden_high_bound);
  153. + }
  154. + 
  155. + /* Given a list of parallel iso_curves, make sure the first one is closest   */
  156. + /* to viewer or reverse in place the list otherwise.                 */
  157. + /* Returns a pointer to the new ordered list.                     */
  158. + static struct iso_curve *reorder_hidden_one_iso_list(orig_list)
  159. + struct iso_curve *orig_list;
  160. + {
  161. +     double first_crv_first_ptz, first_crv_last_ptz,
  162. +            last_crv_first_ptz, last_crv_last_ptz;
  163. +     struct iso_curve *first_crv = orig_list, *last_crv;
  164. + 
  165. +     for (last_crv = first_crv; last_crv->next; last_crv = last_crv->next);
  166. + 
  167. +     first_crv_first_ptz = map3d_z(first_crv->points[0].x,
  168. +                       first_crv->points[0].y,
  169. +                       0.0);
  170. +     first_crv_last_ptz = map3d_z(first_crv->points[first_crv->p_count-1].x,
  171. +                      first_crv->points[first_crv->p_count-1].y,
  172. +                      0.0);
  173. + 
  174. +     last_crv_first_ptz = map3d_z(last_crv->points[0].x,
  175. +                      last_crv->points[0].y,
  176. +                      0.0);
  177. +     last_crv_last_ptz = map3d_z(last_crv->points[last_crv->p_count-1].x,
  178. +                     last_crv->points[last_crv->p_count-1].y,
  179. +                     0.0);
  180. + 
  181. +     /* If first curve is in front of last - do nothing. */
  182. +     if ((first_crv_first_ptz > last_crv_first_ptz &&
  183. +          first_crv_first_ptz > last_crv_last_ptz) ||
  184. +         (first_crv_last_ptz > last_crv_first_ptz &&
  185. +          first_crv_last_ptz > last_crv_last_ptz))
  186. +         return orig_list;
  187. +     else {
  188. +         struct iso_curve *icrv1, *icrv2, *icrv3;
  189. + 
  190. +         /* Need to reverse the list order: */
  191. +         for (icrv1 = orig_list, icrv2 = icrv1->next; icrv2 != NULL; ) {
  192. +         icrv3 = icrv2->next;
  193. +         icrv2->next = icrv1;
  194. +         icrv1 = icrv2;
  195. +             icrv2 = icrv3;
  196. +         }
  197. + 
  198. +         orig_list->next = NULL; /* Now it is the last element. */
  199. + 
  200. +         return icrv1;
  201. +     }
  202. + }
  203. + 
  204. + /* Reorder the list of iso_curves in the surface plot, so it will be drawn   */
  205. + /* from near iso curve to far one in both direction.                 */
  206. + /* Returned is a pointer to new order iso curve list.                 */
  207. + static struct iso_curve *reorder_hidden_iso_curves(plot, num_iso_lines)
  208. +     struct surface_points *plot;
  209. +     int num_iso_lines;
  210. + {
  211. +     int i;
  212. +     struct iso_curve *iso_list1 = plot->iso_crvs, *itmp = iso_list1, *iso_list2;
  213. + 
  214. +     for (i = 1; i < num_iso_lines; i++) itmp = itmp->next;
  215. +     iso_list2 = itmp->next;
  216. +     itmp->next = NULL;
  217. + 
  218. +     iso_list1 = reorder_hidden_one_iso_list(iso_list1);
  219. +     iso_list2 = reorder_hidden_one_iso_list(iso_list2);
  220. +     for (itmp = iso_list1; itmp->next; itmp = itmp->next);
  221. +     itmp->next = iso_list2;
  222. + 
  223. +     plot->iso_crvs = iso_list1;
  224. + 
  225. +     return iso_list1;
  226. + }
  227. + 
  228. + /* Plot a line after removing is hidden part(s). */
  229. + static void hidden_line_plot_aux(x1, y1, x2, y2, style)
  230. + int x1, y1, x2, y2, style;
  231. + {
  232. +     register struct termentry *t = &term_tbl[term];
  233. + 
  234. +     if (x2 < x1 || (x2 == x1 && y1 == y2)) return;
  235. + 
  236. +     (*t->linetype)(style);
  237. +     (*t->move)(x1,y1);
  238. +     (*t->vector)(x2,y2);
  239. + }
  240. + 
  241. + /* Plot a line after removing is hidden part(s). */
  242. + static void hidden_line_plot(x1, y1, x2, y2)
  243. + int x1, y1, x2, y2;
  244. + {
  245. +     int x, last_x, last_y, visible_above, visible_below;
  246. +     float dy, y;
  247. + 
  248. +     if (x1 > x2) {
  249. +     x = x1;
  250. +     x1 = x2;
  251. +     x2 = x;
  252. + 
  253. +     y = y1;
  254. +     y1 = y2;
  255. +     y2 = y;
  256. +     }
  257. + 
  258. +     if (hidden_first_row) {
  259. +     /* All is visible and drawn as visible above. */
  260. +     dy = x1 != x2 ? ((float) (y2 - y1)) / ((float) (x2 - x1)) : VERYLARGE;
  261. + 
  262. +     for (x = x1, y = y1; x <= x2; x++, y = y1 + (x - x1) * dy) {
  263. +         SET_HIDDEN_BOUND(hidden_high_bound, x, (int) y);
  264. +         SET_HIDDEN_BOUND(hidden_low_bound, x, (int) y);
  265. +     }
  266. +         hidden_line_plot_aux(x1, y1, x2, y2, hidden_line_type_above);
  267. +     }
  268. +     else {
  269. +     if (x1 == x2) {
  270. +         if (y1 > y2) {
  271. +         y = y1;
  272. +         y1 = y2;
  273. +         y2 = y;
  274. +         }
  275. + 
  276. +         /* Clip properly this verical line to right bounds. Note clipping
  277. +          * may produce upto two segments.
  278. +          */
  279. +         if (y1 <= HIDDEN_LOW_BOUND(x1) && y2 <= HIDDEN_LOW_BOUND(x1))
  280. +         hidden_line_plot_aux(x1, y1, x2, y2, hidden_line_type_below);
  281. +         else if (y1 >= HIDDEN_HIGH_BOUND(x1) && y2 >= HIDDEN_HIGH_BOUND(x1))  
  282. +         hidden_line_plot_aux(x1, y1, x2, y2, hidden_line_type_above);
  283. +         else {
  284. +             if (y1 < HIDDEN_LOW_BOUND(x1) && y2 > HIDDEN_LOW_BOUND(x1))
  285. +             hidden_line_plot_aux(x1, y1, x2, HIDDEN_LOW_BOUND(x1),
  286. +                          hidden_line_type_below);
  287. +             if (y2 > HIDDEN_HIGH_BOUND(x1) && y1 < HIDDEN_HIGH_BOUND(x1))
  288. +             hidden_line_plot_aux(x1, HIDDEN_HIGH_BOUND(x1), x2, y2,
  289. +                          hidden_line_type_above);
  290. +         }
  291. +         return;
  292. +     }
  293. +     else
  294. +         dy = ((float) (y2 - y1)) / ((float) (x2 - x1));
  295. + 
  296. +     visible_above = y1 >= HIDDEN_HIGH_BOUND(x1);
  297. +     visible_below = y1 <= HIDDEN_LOW_BOUND(x1);
  298. +     if (visible_above || visible_below) {
  299. +         if (visible_above && visible_below) visible_below = FALSE;
  300. +         last_x = x1;
  301. +         last_y = y1;
  302. +     }
  303. +         for (x = x1, y = y1; x < x2; x++, y += dy)
  304. +     {
  305. +         if (y >= HIDDEN_HIGH_BOUND(x)) {
  306. +         if (visible_below) {
  307. +             hidden_line_plot_aux(last_x, last_y, x - 1, (int) (y - dy),
  308. +                      hidden_line_type_below);
  309. +             visible_below = FALSE;
  310. +         }
  311. +         if (!visible_above) {
  312. +             visible_above = TRUE;
  313. +             last_x = x;
  314. +             last_y = (int) y;
  315. +         }
  316. +         if (!hidden_no_update)
  317. +             SET_HIDDEN_BOUND(hidden_high_bound, x, (int) y);
  318. +         }
  319. +         else if (y <= HIDDEN_LOW_BOUND(x)) {
  320. +         if (visible_above) {
  321. +             hidden_line_plot_aux(last_x, last_y, x - 1, (int) (y - dy),
  322. +                      hidden_line_type_above);
  323. +             visible_above = FALSE;
  324. + 
  325. +         }
  326. +         if (!visible_below) {
  327. +             visible_below = TRUE;
  328. +             last_x = x;
  329. +             last_y = (int) y;
  330. +         }
  331. +         if (!hidden_no_update)
  332. +             SET_HIDDEN_BOUND(hidden_low_bound, x, (int) y);
  333. +         }
  334. +         else {
  335. +         if (visible_above) {
  336. +             hidden_line_plot_aux(last_x, last_y, x - 1, (int) (y - dy),
  337. +                      hidden_line_type_above);
  338. +             visible_above = visible_below = FALSE;
  339. +         }
  340. +         else if (visible_below) {
  341. +             hidden_line_plot_aux(last_x, last_y, x - 1, (int) (y - dy),
  342. +                      hidden_line_type_below);
  343. +             visible_below = FALSE;
  344. +         }
  345. +         }
  346. +     }
  347. + 
  348. +     if (visible_above) {
  349. +         hidden_line_plot_aux(last_x, last_y, x2, y2,
  350. +                  hidden_line_type_above);
  351. +     }
  352. +     else if (visible_below) {
  353. +         hidden_line_plot_aux(last_x, last_y, x2, y2,
  354. +                  hidden_line_type_below);
  355. +     }
  356. +     }
  357. + }
  358. + 
  359.   /* Test a single point to be within the xleft,xright,ybot,ytop bbox.
  360.    * Sets the returned integers 4 l.s.b. as follows:
  361.    * bit 0 if to the left of xleft.
  362. ***************
  363. *** 251,257 ****
  364.    * bit 3 if below of ybot.
  365.    * 0 is returned if inside.
  366.    */
  367. ! static int clip_point(x, y)
  368.   int x, y;
  369.   {
  370.       int ret_val = 0;
  371. --- 542,548 ----
  372.    * bit 3 if below of ybot.
  373.    * 0 is returned if inside.
  374.    */
  375. ! static int clip_point_for_clip_line(x, y)
  376.   int x, y;
  377.   {
  378.       int ret_val = 0;
  379. ***************
  380. *** 264,269 ****
  381. --- 555,573 ----
  382.       return ret_val;
  383.   }
  384.   
  385. + /* Test a single point to be within the xleft,xright,ybot,ytop bbox.
  386. +  * and it is not hidden if hidden lines are to be removed.
  387. +  */
  388. + static int clip_point(x, y)
  389. + int x, y;
  390. + {
  391. +     if (hidden_active &&
  392. +     HIDDEN_LOW_BOUND(x) <= y && HIDDEN_HIGH_BOUND(x) >= y)
  393. +     return FALSE;
  394. + 
  395. +     return clip_point_for_clip_line(x, y);
  396. + }
  397. + 
  398.   /* Clip the given line to drawing coords defined as xleft,xright,ybot,ytop.
  399.    *   This routine uses the cohen & sutherland bit mapping for fast clipping -
  400.    * see "Principles of Interactive Computer Graphics" Newman & Sproull page 65.
  401. ***************
  402. *** 274,281 ****
  403.       int x, y, dx, dy, x_intr[2], y_intr[2], count, pos1, pos2;
  404.       register struct termentry *t = &term_tbl[term];
  405.   
  406. !     pos1 = clip_point(x1, y1);
  407. !     pos2 = clip_point(x2, y2);
  408.       if (pos1 || pos2) {
  409.       if (pos1 & pos2) return;          /* segment is totally out. */
  410.   
  411. --- 578,585 ----
  412.       int x, y, dx, dy, x_intr[2], y_intr[2], count, pos1, pos2;
  413.       register struct termentry *t = &term_tbl[term];
  414.   
  415. !     pos1 = clip_point_for_clip_line(x1, y1);
  416. !     pos2 = clip_point_for_clip_line(x2, y2);
  417.       if (pos1 || pos2) {
  418.       if (pos1 & pos2) return;          /* segment is totally out. */
  419.   
  420. ***************
  421. *** 359,366 ****
  422.           return;
  423.       }
  424.   
  425. !     (*t->move)(x1,y1);
  426. !     (*t->vector)(x2,y2);
  427.   }
  428.   
  429.   /* Two routine to emulate move/vector sequence using line drawing routine. */
  430. --- 663,675 ----
  431.           return;
  432.       }
  433.   
  434. !     if (hidden_active) {
  435. !     hidden_line_plot(x1, y1, x2, y2);
  436. !     }
  437. !     else {
  438. !     (*t->move)(x1,y1);
  439. !     (*t->vector)(x2,y2);
  440. !     }
  441.   }
  442.   
  443.   /* Two routine to emulate move/vector sequence using line drawing routine. */
  444. ***************
  445. *** 569,574 ****
  446. --- 878,894 ----
  447.       if (fabs(z_max3d - z_min3d) < zero)
  448.       int_error("z_min3d should not equal z_max3d!",NO_CARET);
  449.   
  450. +     if (hidden3d) {
  451. +     struct surface_points *plot;
  452. +     
  453. +         /* Verify data is hidden line removable - nonparametric + grid based. */
  454. +         for (plot = plots; plot != NULL; plot = plot->next_sp) {
  455. +         if (parametric ||
  456. +             (plot->plot_type == DATA3D && !plot->has_grid_topology))
  457. +             int_error("Cannot hidden line remove parametric surface or non grid data\n", NO_CARET);
  458. +         }
  459. +     }
  460. + 
  461.   /* INITIALIZE TERMINAL */
  462.       if (!term_init) {
  463.       (*t->init)();
  464. ***************
  465. *** 587,592 ****
  466. --- 907,913 ----
  467.       xscale3d = 2.0/(x_max3d - x_min3d);
  468.   
  469.       (*t->linetype)(-2); /* border linetype */
  470. + 
  471.   /* PLACE TITLE */
  472.       if (*title != 0) {
  473.           int x, y;
  474. ***************
  475. *** 681,686 ****
  476. --- 1002,1012 ----
  477.       (*t->arrow)(sx, sy, ex, ey, this_arrow->head);
  478.       }
  479.   
  480. +     if (hidden3d) {
  481. +     init_hidden_line_removal();
  482. +     reset_hidden_line_removal();
  483. +     hidden_active = TRUE;
  484. +     }
  485.   
  486.   /* DRAW SURFACES AND CONTOURS */
  487.       real_z_min3d = min_z;
  488. ***************
  489. *** 700,710 ****
  490.       for (surface = 0;
  491.            surface < pcount;
  492.            this_plot = this_plot->next_sp, surface++) {
  493. !         (*t->linetype)(this_plot->line_type+1);
  494.   
  495.           if (draw_contour && this_plot->contours != NULL) {
  496.               struct gnuplot_contours *cntrs = this_plot->contours;
  497.   
  498.               if (key != 0) {
  499.                   if ((*t->justify_text)(RIGHT)) {
  500.                       clip_put_text(xl,
  501. --- 1026,1118 ----
  502.       for (surface = 0;
  503.            surface < pcount;
  504.            this_plot = this_plot->next_sp, surface++) {
  505. !         if ( hidden3d )
  506. !             hidden_no_update = FALSE;
  507.   
  508. +         if (draw_surface) {
  509. +             (*t->linetype)(this_plot->line_type);
  510. +             if (hidden3d) {
  511. +             hidden_line_type_above = this_plot->line_type;
  512. +             hidden_line_type_below = this_plot->line_type + 1;
  513. +             }
  514. +             
  515. +             if (key != 0) {
  516. +             if ((*t->justify_text)(RIGHT)) {
  517. +                 clip_put_text(xl,
  518. +                       yl,this_plot->title);
  519. +             }
  520. +             else {
  521. +                 if (inrange(xl-(t->h_char)*strlen(this_plot->title), 
  522. +                     xleft, xright))
  523. +                 clip_put_text(xl-(t->h_char)*strlen(this_plot->title),
  524. +                           yl,this_plot->title);
  525. +             }
  526. +             }
  527. +             
  528. +             switch(this_plot->plot_style) {
  529. +                 case IMPULSES: {
  530. +                 if (key != 0) {
  531. +                 clip_move(xl+(t->h_char),yl);
  532. +                 clip_vector(xl+4*(t->h_char),yl);
  533. +                 }
  534. +                 plot3d_impulses(this_plot);
  535. +                 break;
  536. +             }
  537. +             case LINES: {
  538. +                 if (key != 0) {
  539. +                 clip_move(xl+(int)(t->h_char),yl);
  540. +                 clip_vector(xl+(int)(4*(t->h_char)),yl);
  541. +                 }
  542. +                 plot3d_lines(this_plot);
  543. +                 break;
  544. +             }
  545. +             case ERRORBARS:    /* ignored; treat like points */
  546. +             case POINTS: {
  547. +                 if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  548. +                 (*t->point)(xl+2*(t->h_char),yl,
  549. +                         this_plot->point_type);
  550. +                 }
  551. +                 plot3d_points(this_plot);
  552. +                 break;
  553. +             }
  554. +             case LINESPOINTS: {
  555. +                 /* put lines */
  556. +                 if (key != 0) {
  557. +                 clip_move(xl+(t->h_char),yl);
  558. +                 clip_vector(xl+4*(t->h_char),yl);
  559. +                 }
  560. +                 plot3d_lines(this_plot);
  561. +             
  562. +                 /* put points */
  563. +                 if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  564. +                 (*t->point)(xl+2*(t->h_char),yl,
  565. +                         this_plot->point_type);
  566. +                 }
  567. +                 plot3d_points(this_plot);
  568. +                 break;
  569. +             }
  570. +             case DOTS: {
  571. +                 if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  572. +                 (*t->point)(xl+2*(t->h_char),yl, -1);
  573. +                 }
  574. +                 plot3d_dots(this_plot);
  575. +                 break;
  576. +             }
  577. +             }
  578. +             yl = yl - (t->v_char);
  579. +         }
  580. + 
  581. +         if ( hidden3d ) {
  582. +             hidden_no_update = TRUE;
  583. +             hidden_line_type_above = this_plot->line_type + (hidden3d ? 2 : 1);
  584. +             hidden_line_type_below = this_plot->line_type + (hidden3d ? 2 : 1);
  585. +         }
  586. + 
  587.           if (draw_contour && this_plot->contours != NULL) {
  588.               struct gnuplot_contours *cntrs = this_plot->contours;
  589.   
  590. +             (*t->linetype)(this_plot->line_type + (hidden3d ? 2 : 1));
  591. + 
  592.               if (key != 0) {
  593.                   if ((*t->justify_text)(RIGHT)) {
  594.                       clip_put_text(xl,
  595. ***************
  596. *** 769,847 ****
  597.               if (key != 0) yl = yl - (t->v_char);
  598.           }
  599.   
  600. !         if ( surface == 0 )
  601. !             draw_bottom_grid(this_plot,real_z_min3d,real_z_max3d);
  602. ! 
  603. !         if (!draw_surface) continue;
  604. !         (*t->linetype)(this_plot->line_type);
  605. ! 
  606. !         if (key != 0) {
  607. !             if ((*t->justify_text)(RIGHT)) {
  608. !                 clip_put_text(xl,
  609. !                     yl,this_plot->title);
  610. !             }
  611. !             else {
  612. !                 if (inrange(xl-(t->h_char)*strlen(this_plot->title), 
  613. !                          xleft, xright))
  614. !                  clip_put_text(xl-(t->h_char)*strlen(this_plot->title),
  615. !                              yl,this_plot->title);
  616. !             }
  617. !         }
  618. !  
  619. !         switch(this_plot->plot_style) {
  620. !             case IMPULSES: {
  621. !                if (key != 0) {
  622. !                   clip_move(xl+(t->h_char),yl);
  623. !                   clip_vector(xl+4*(t->h_char),yl);
  624. !                }
  625. !                plot3d_impulses(this_plot);
  626. !                break;
  627. !             }
  628. !             case LINES: {
  629. !                if (key != 0) {
  630. !                   clip_move(xl+(int)(t->h_char),yl);
  631. !                   clip_vector(xl+(int)(4*(t->h_char)),yl);
  632. !                }
  633. !                plot3d_lines(this_plot);
  634. !                break;
  635. !             }
  636. !             case ERRORBARS:    /* ignored; treat like points */
  637. !             case POINTS: {
  638. !                if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  639. !                   (*t->point)(xl+2*(t->h_char),yl,
  640. !                             this_plot->point_type);
  641. !                }
  642. !                plot3d_points(this_plot);
  643. !                break;
  644. !             }
  645. !             case LINESPOINTS: {
  646. !                /* put lines */
  647. !                if (key != 0) {
  648. !                   clip_move(xl+(t->h_char),yl);
  649. !                   clip_vector(xl+4*(t->h_char),yl);
  650. !                }
  651. !                plot3d_lines(this_plot);
  652. ! 
  653. !                /* put points */
  654. !                if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  655. !                   (*t->point)(xl+2*(t->h_char),yl,
  656. !                             this_plot->point_type);
  657. !                }
  658. !                plot3d_points(this_plot);
  659. !                break;
  660. !             }
  661. !             case DOTS: {
  662. !                if (key != 0 && !clip_point(xl+2*(t->h_char),yl)) {
  663. !                   (*t->point)(xl+2*(t->h_char),yl, -1);
  664. !                }
  665. !                plot3d_dots(this_plot);
  666. !                break;
  667. !             }
  668. !         }
  669. !         yl = yl - (t->v_char);
  670.       }
  671.       (*t->text)();
  672.       (void) fflush(outfile);
  673.   }
  674.   
  675.   /* plot3d_impulses:
  676. --- 1177,1192 ----
  677.               if (key != 0) yl = yl - (t->v_char);
  678.           }
  679.   
  680. !         if (surface == 0)
  681. !             draw_bottom_grid(this_plot,real_z_min3d,real_z_max3d);
  682.       }
  683.       (*t->text)();
  684.       (void) fflush(outfile);
  685. + 
  686. +     if (hidden3d) {
  687. +         term_hidden_line_removal();
  688. +         hidden_active = FALSE;
  689. +     }
  690.   }
  691.   
  692.   /* plot3d_impulses:
  693. ***************
  694. *** 881,895 ****
  695.   static plot3d_lines(plot)
  696.       struct surface_points *plot;
  697.   {
  698. !     int i;
  699.       int x,y;                /* point in terminal coordinates */
  700.       struct termentry *t = &term_tbl[term];
  701. !     struct iso_curve *icrvs = plot->iso_crvs;
  702.   
  703. !     while ( icrvs ) {
  704. !     struct coordinate *points = icrvs->points;
  705.   
  706. !     for (i = 0; i < icrvs->p_count; i++) {
  707.           if (real_z_max3d<points[i].z)
  708.           real_z_max3d=points[i].z;
  709.           if (real_z_min3d>points[i].z)
  710. --- 1226,1280 ----
  711.   static plot3d_lines(plot)
  712.       struct surface_points *plot;
  713.   {
  714. !     int i, iso_count, num_iso_lines;
  715.       int x,y;                /* point in terminal coordinates */
  716.       struct termentry *t = &term_tbl[term];
  717. !     struct iso_curve *icrvs = plot->iso_crvs,
  718. !        *first_row_icrv, *last_row_icrv, *first_col_icrv, *icrv;
  719. !     struct coordinate *points;
  720.   
  721. !     if (hidden3d) {
  722. !     hidden_no_update = FALSE;
  723.   
  724. !     if (plot->plot_type == FUNC3D)
  725. !         num_iso_lines = iso_samples;
  726. !     else
  727. !         num_iso_lines = plot->num_iso_read;
  728. ! 
  729. !     icrvs = reorder_hidden_iso_curves(plot, num_iso_lines);
  730. ! 
  731. !     first_row_icrv = icrvs;
  732. !     for (last_row_icrv = icrvs, i = 1;
  733. !          i++ < num_iso_lines;
  734. !          last_row_icrv = last_row_icrv->next);
  735. !     first_col_icrv = last_row_icrv->next;
  736. !     reset_hidden_line_removal();
  737. ! 
  738. !     iso_count = 1;
  739. !     }
  740. ! 
  741. !     while (icrvs) {
  742. !     if (hidden3d) {
  743. !         if (iso_count == 1 || iso_count == num_iso_lines + 1) {
  744. !         hidden_first_row = TRUE;
  745. ! 
  746. !         /* Draw other boundary so low/high bounds will be complete: */
  747. !         icrv = iso_count == 1 ? first_col_icrv : first_row_icrv;
  748. !         for (i = 0, points = icrv->points; i < icrv->p_count; i++) {
  749. !             map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  750. ! 
  751. !             if (i > 0)
  752. !             clip_vector(x,y);
  753. !             else
  754. !             clip_move(x,y);
  755. !         }
  756. !         }
  757. !         else
  758. !         hidden_first_row = FALSE;
  759. !         iso_count++;
  760. !     }
  761. ! 
  762. !     for (i = 0, points = icrvs->points; i < icrvs->p_count; i++) {
  763.           if (real_z_max3d<points[i].z)
  764.           real_z_max3d=points[i].z;
  765.           if (real_z_min3d>points[i].z)
  766. ***************
  767. *** 905,910 ****
  768. --- 1290,1308 ----
  769.   
  770.       icrvs = icrvs->next;
  771.       }
  772. + 
  773. +     if (hidden3d) {
  774. +     /* Draw other boundary so low/high bounds will be complete: */
  775. +     for (i = 0, points = last_row_icrv->points;
  776. +          i < last_row_icrv->p_count; i++) {
  777. +         map3d_xy(points[i].x, points[i].y, points[i].z, &x, &y);
  778. + 
  779. +         if (i > 0)
  780. +         clip_vector(x,y);
  781. +         else
  782. +         clip_move(x,y);
  783. +     }
  784. +     }
  785.   }
  786.   
  787.   /* plot3d_points:
  788. ***************
  789. *** 1165,1174 ****
  790.       dy = (y_max3d-y_min3d) / (grid_iso-1);
  791.   
  792.       for (i = 0; i < grid_iso; i++) {
  793. !             if (i == 0 || i == grid_iso-1)
  794. !             (*t->linetype)(-2);
  795.           else
  796. !             (*t->linetype)(-1);
  797.           map3d_xy(x_min3d, y, z_min3d, &ix, &iy);
  798.           clip_move(ix,iy);
  799.           update_extrema_pts(ix,iy,&min_sx_x,&min_sx_y,
  800. --- 1563,1572 ----
  801.       dy = (y_max3d-y_min3d) / (grid_iso-1);
  802.   
  803.       for (i = 0; i < grid_iso; i++) {
  804. !             if (i == 0 || i == grid_iso-1)            
  805. !             setlinestyle(-2);
  806.           else
  807. !             setlinestyle(-1);
  808.           map3d_xy(x_min3d, y, z_min3d, &ix, &iy);
  809.           clip_move(ix,iy);
  810.           update_extrema_pts(ix,iy,&min_sx_x,&min_sx_y,
  811. ***************
  812. *** 1184,1192 ****
  813.   
  814.       for (i = 0; i < grid_iso; i++) {
  815.               if (i == 0 || i == grid_iso-1)
  816. !             (*t->linetype)(-2);
  817.           else
  818. !             (*t->linetype)(-1);
  819.           map3d_xy(x, y_min3d, z_min3d, &ix, &iy);
  820.           clip_move(ix,iy);
  821.           update_extrema_pts(ix,iy,&min_sx_x,&min_sx_y,
  822. --- 1582,1590 ----
  823.   
  824.       for (i = 0; i < grid_iso; i++) {
  825.               if (i == 0 || i == grid_iso-1)
  826. !             setlinestyle(-2);
  827.           else
  828. !             setlinestyle(-1);
  829.           map3d_xy(x, y_min3d, z_min3d, &ix, &iy);
  830.           clip_move(ix,iy);
  831.           update_extrema_pts(ix,iy,&min_sx_x,&min_sx_y,
  832. ***************
  833. *** 1201,1207 ****
  834.       }
  835.       }
  836.       else {
  837. !     (*t->linetype)(-2);
  838.   
  839.       map3d_xy(x_min3d, y_min3d, z_min3d, &ix, &iy);
  840.       clip_move(ix,iy);
  841. --- 1599,1605 ----
  842.       }
  843.       }
  844.       else {
  845. !     setlinestyle(-2);
  846.   
  847.       map3d_xy(x_min3d, y_min3d, z_min3d, &ix, &iy);
  848.       clip_move(ix,iy);
  849. ***************
  850. *** 1245,1258 ****
  851.   
  852.       while ( icrvs ) {
  853.       struct coordinate *points = icrvs->points;
  854.   
  855.       for (i = 0; i < icrvs->p_count; i += icrvs->p_count-1) {
  856.           map3d_xy(points[i].x, points[i].y, z_min3d, &x, &y);
  857.           if (is_boundary) {
  858. !         (*t->linetype)(-2);
  859.           }
  860.           else {
  861. !             (*t->linetype)(-1);
  862.           }
  863.   
  864.           if (i > 0) {
  865. --- 1643,1660 ----
  866.   
  867.       while ( icrvs ) {
  868.       struct coordinate *points = icrvs->points;
  869. +     int saved_hidden_active = hidden_active;
  870. +     double z1 = map3d_z(points[0].x, points[0].y, 0.0),
  871. +            z2 = map3d_z(points[icrvs->p_count-1].x,
  872. +                             points[icrvs->p_count-1].y, 0.0);
  873.   
  874.       for (i = 0; i < icrvs->p_count; i += icrvs->p_count-1) {
  875.           map3d_xy(points[i].x, points[i].y, z_min3d, &x, &y);
  876.           if (is_boundary) {
  877. !         setlinestyle(-2);
  878.           }
  879.           else {
  880. !             setlinestyle(-1);
  881.           }
  882.   
  883.           if (i > 0) {
  884. ***************
  885. *** 1269,1276 ****
  886. --- 1671,1685 ----
  887.   
  888.           /* Draw a vertical line to surface corner from grid corner. */
  889.               map3d_xy(points[i].x, points[i].y, points[i].z, &x1, &y1);
  890. +             if (hidden3d) {
  891. +             if ((i == 0 && z1 > z2) ||
  892. +                 (i == icrvs->p_count-1 && z2 > z1)) {
  893. +                 hidden_active = FALSE; /* This one is always visible. */
  894. +             }                
  895. +             }
  896.               clip_vector(x1,y1);
  897.               clip_move(x,y);
  898. +         hidden_active = saved_hidden_active;
  899.           update_extrema_pts(x,y,&min_sx_x,&min_sx_y, &min_sy_x,&min_sy_y,
  900.                      points[i].x,points[i].y);
  901.           }
  902. ***************
  903. *** 1324,1330 ****
  904.       else
  905.           draw_non_param_grid(plot);
  906.   
  907. !     (*t->linetype)(-2); /* border linetype */
  908.   
  909.   /* label x axis tics */
  910.       if (xtics && xtic > 0.0) {
  911. --- 1733,1739 ----
  912.       else
  913.           draw_non_param_grid(plot);
  914.   
  915. !     setlinestyle(-2); /* border linetype */
  916.   
  917.   /* label x axis tics */
  918.       if (xtics && xtic > 0.0) {
  919. ***************
  920. *** 1557,1563 ****
  921.       }
  922.   
  923.       /* Make sure the vertical line is fully drawn. */
  924. !     (*t->linetype)(-2);    /* axis line type */
  925.   
  926.       map3d_xy(xpos, ypos, z_min3d, &x, &y);
  927.       clip_move(x,y);
  928. --- 1966,1972 ----
  929.       }
  930.   
  931.       /* Make sure the vertical line is fully drawn. */
  932. !     setlinestyle(-2);    /* axis line type */
  933.   
  934.       map3d_xy(xpos, ypos, z_min3d, &x, &y);
  935.       clip_move(x,y);
  936. ***************
  937. *** 1564,1570 ****
  938.       map3d_xy(xpos, ypos, min(end,z_max)+(log_z ? incr : 0.0), &x, &y);
  939.       clip_vector(x,y);
  940.   
  941. !     (*t->linetype)(-1); /* border linetype */
  942.   }
  943.   
  944.   /* DRAW_SERIES_3DXTICS: draw a user tic series, x axis */
  945. --- 1973,1979 ----
  946.       map3d_xy(xpos, ypos, min(end,z_max)+(log_z ? incr : 0.0), &x, &y);
  947.       clip_vector(x,y);
  948.   
  949. !     setlinestyle(-1); /* border linetype */
  950.   }
  951.   
  952.   /* DRAW_SERIES_3DXTICS: draw a user tic series, x axis */
  953. ***************
  954. *** 1651,1657 ****
  955.       }
  956.   
  957.       /* Make sure the vertical line is fully drawn. */
  958. !     (*t->linetype)(-2);    /* axis line type */
  959.   
  960.       map3d_xy(xpos, ypos, z_min3d, &x, &y);
  961.       clip_move(x,y);
  962. --- 2060,2066 ----
  963.       }
  964.   
  965.       /* Make sure the vertical line is fully drawn. */
  966. !     setlinestyle(-2);    /* axis line type */
  967.   
  968.       map3d_xy(xpos, ypos, z_min3d, &x, &y);
  969.       clip_move(x,y);
  970. ***************
  971. *** 1658,1664 ****
  972.       map3d_xy(xpos, ypos, min(end,z_max)+(log_z ? incr : 0.0), &x, &y);
  973.       clip_vector(x,y);
  974.   
  975. !     (*t->linetype)(-1); /* border linetype */
  976.   }
  977.   
  978.   /* DRAW_SET_3DXTICS: draw a user tic set, x axis */
  979. --- 2067,2073 ----
  980.       map3d_xy(xpos, ypos, min(end,z_max)+(log_z ? incr : 0.0), &x, &y);
  981.       clip_vector(x,y);
  982.   
  983. !     setlinestyle(-1); /* border linetype */
  984.   }
  985.   
  986.   /* DRAW_SET_3DXTICS: draw a user tic set, x axis */
  987. ***************
  988. *** 1722,1728 ****
  989.       }
  990.   
  991.       /* Make sure the vertical line is fully drawn. */
  992. !     (*t->linetype)(-2);    /* axis line type */
  993.   
  994.       map3d_xy(xpos, ypos, z_min, &x, &y);
  995.       clip_move(x,y);
  996. --- 2131,2137 ----
  997.       }
  998.   
  999.       /* Make sure the vertical line is fully drawn. */
  1000. !     setlinestyle(-2);    /* axis line type */
  1001.   
  1002.       map3d_xy(xpos, ypos, z_min, &x, &y);
  1003.       clip_move(x,y);
  1004. ***************
  1005. *** 1729,1735 ****
  1006.       map3d_xy(xpos, ypos, z_max+(log_z ? incr : 0.0), &x, &y);
  1007.       clip_vector(x,y);
  1008.   
  1009. !     (*t->linetype)(-1); /* border linetype */
  1010.   }
  1011.   
  1012.   /* draw and label a x-axis ticmark */
  1013. --- 2138,2144 ----
  1014.       map3d_xy(xpos, ypos, z_max+(log_z ? incr : 0.0), &x, &y);
  1015.       clip_vector(x,y);
  1016.   
  1017. !     setlinestyle(-1); /* border linetype */
  1018.   }
  1019.   
  1020.   /* draw and label a x-axis ticmark */
  1021.