Make the axis appears before the curve surface shows up.
[dyninst.git] / visiClients / terrain / src / command.c
1 /* GNUPLOT - command.c */
2 /*
3  * Copyright (C) 1986, 1987, 1990   Thomas Williams, Colin Kelley
4  *
5  * Permission to use, copy, and distribute this software and its
6  * documentation for any purpose with or without fee is hereby granted, 
7  * provided that the above copyright notice appear in all copies and 
8  * that both that copyright notice and this permission notice appear 
9  * in supporting documentation.
10  *
11  * Permission to modify the software is granted, but not the right to
12  * distribute the modified code.  Modifications are to be distributed 
13  * as patches to released version.
14  *  
15  * This software  is provided "as is" without express or implied warranty.
16  * 
17  *
18  * AUTHORS
19  * 
20  *   Original Software:
21  *     Thomas Williams,  Colin Kelley.
22  * 
23  *   Gnuplot 2.0 additions:
24  *       Russell Lang, Dave Kotz, John Campbell.
25  * 
26  * send your comments or suggestions to (pixar!info-gnuplot@sun.com).
27  *
28  */
29
30 /*
31  * Heavily modified for Terrain Plot:
32  *    Chi-Ting Lam     (Apr 25, 1992).
33  *
34  * send you comments or suggestions to (ips@cs.wisc.edu).
35  *
36  */     
37
38 #ifndef lint
39 static char rcsid[] = "@(#) $Header: /home/jaw/CVSROOT_20081103/CVSROOT/core/visiClients/terrain/src/command.c,v 1.5 1997/05/19 19:43:06 tung Exp $";
40 #endif
41
42 /*
43  * command.c - main switchboard of the program.
44  *
45  * $Log: command.c,v $
46  * Revision 1.5  1997/05/19 19:43:06  tung
47  * Make the axis appears before the curve surface shows up.
48  *
49  * Revision 1.4  1997/05/19 01:00:08  tung
50  * Eliminate ips dependent library files.
51  *
52  * Revision 1.3  1997/05/18 22:50:10  tung
53  * Eliminate ips dependent library files.
54  *
55  * Revision 1.2  1997/05/14 19:14:55  naim
56  * Minor changes for sunos version of terrain - naim
57  *
58  * Revision 1.1  1997/05/12 20:15:23  naim
59  * Adding "Terrain" visualization to paradyn (commited by naim, done by tung).
60  *
61  * Revision 1.4  1992/05/19  20:21:01  lam
62  * Added detection for dead master when checking visible nodes.
63  * But terrain die (no core dum) when this happen for unknown reason.
64  *
65  * Revision 1.3  1992/05/19  18:43:13  lam
66  * Correction on error mesesages.
67  *
68  * Revision 1.2  1992/05/19  17:30:23  lam
69  * Treat not enough visible notes as a warning instead of an error.
70  *
71  * Revision 1.1  1992/05/19  06:30:55  lam
72  * Initial revision
73  *
74  *
75  */
76
77 #include <stdio.h>
78 #include <math.h>
79 /* #include <strings.h> */
80
81 #include "plot.h"
82 #include "setshow.h"
83
84 #include "misc.h"
85 #include "smooth.h"
86 #include "command.h"
87 #include "terrain.h"
88
89
90 #define inrange(z,min,max) ((min<max) ? ((z>=min)&&(z<=max)) : ((z>=max)&&(z<=min)) )
91
92 extern struct at_type *temp_at(), *perm_at();
93 extern void squash_spaces();
94 extern void lower_case();
95
96 /* Local functions */
97 struct surface_points *get_newplot();
98
99 /* Reduce needs screen width */
100 extern W;
101
102 /* input data, parsing variables */
103 struct lexical_unit token[MAX_TOKENS];
104 char input_line[MAX_LINE_LEN+1];
105 int num_tokens, c_token;
106 int inline_num = 0;                     /* input line number */
107
108 char *data_file;
109
110 /* new variables for dynamic graph */
111 static struct surface_points *curves = 0;  /* the surface of points */
112 static const float y_interval = 1;         /* the separation of each curve */
113 static float x_interval;
114 static int nopoints;                       /* the number of points on each curve */
115 static int nocurves;
116 static int change = 0;
117
118 /* Different kinds of plots which plot3drequest manages.
119  * Note that the order is important here since they are organized in
120  * a binary tree form.
121  */
122
123 #define S_ORIG 8
124 #define S_HIDE 4
125 #define S_MINI 2
126 #define S_SMTH 1
127 #define S_REDU 0
128
129 #define WIN_SIZE 5              /* Hard-wired smooth window size */
130
131 /* variables as indicator when smooth data or med is need */
132 static int is_smooth = 0,       /* Default is no smoothing  */
133            is_med = 0;          /* Default is using mean for smoothing */
134
135
136
137 /********************************************************************
138 *
139 * plot3drequest - The main switch broad for drawing terrains.
140 *
141 * plot3drequest draw the approiate terrain (and do the related
142 * calculations) accroding to the action given.
143 *
144 * The possible actions are in command.h
145 *
146 ********************************************************************/
147
148 plot3drequest(action)
149 int action;
150 {
151     int reDraw_atOnce = 0;
152     color_mode = 1;             /* No color only when rotating */
153
154
155     switch (action) {
156         case SA_ROTATE: color_mode = 0;
157                         reDraw_atOnce = 1;
158
159                    break;
160
161         case SA_JUMP:   reDraw_atOnce = 1;
162                         break;  /* Just redraw with the new view angle */
163
164         case SA_SMOOTH: is_smooth = 1;
165                         reDraw_atOnce = 1;;
166                    break;
167
168         case SA_ROUGH:  is_smooth = 0;
169                         change = 1;
170                    break;
171
172         case SA_USEMED: is_med = 1;
173                         if (is_smooth == 1)
174                            change = 1;
175                    break;
176
177         case SA_NOMED:  is_med = 0;
178                         change = 1;
179                    break;
180
181
182         case SA_RESIZE: reDraw_atOnce = 1;
183                    break;
184         
185         default: terrain_error("Wrong display command!");
186                  break;
187     }
188
189        ReDisplayGraph();
190
191
192 }
193
194
195 /* Keep old GNUPlot code happy */
196
197 done(status)
198 int status;
199 {
200         exit(status);
201 }
202
203
204 /***********************************************************************
205  ******************** modified section starts***************************/
206  
207
208
209 int getStartIndex(ID)
210 int ID;
211 {
212
213   return ID * nopoints;
214
215 }
216
217
218 void kill_surface()
219 {
220   if (curves != NULL)
221      free_surface(curves);
222 }
223
224
225 int checkDecimal(zmax)
226 float zmax;
227 {
228   int i = 0;
229
230   if (zmax > 10)
231      return -1;
232
233   for (i = 0; zmax < 1; i++)
234       zmax *=10;
235
236   return i;
237
238 }
239
240
241
242 void ReDisplayGraph()
243 {
244
245   struct surface_points *thisCurve;
246   int del = 0;
247
248   if (is_smooth == 1 && curves != 0)
249   {
250      thisCurve = (struct surface_points* ) terrain_alloc(sizeof(struct surface_points));
251      if (is_med == 1)
252      {
253         smooth_med(thisCurve, curves, WIN_SIZE);
254         del = 1;
255      }
256      else
257      {
258         smooth(thisCurve, curves, WIN_SIZE, curves->lastprintIndex);
259         del = 1;
260      }
261   }
262   else
263      thisCurve = curves;
264
265   if (thisCurve != 0 && thisCurve->iso_samples > 1)
266   {
267      float minx = thisCurve->x_min;
268      float maxx = thisCurve->x_max;
269      float miny = thisCurve->y_min;
270      float maxy = thisCurve->y_max;
271      float minz = thisCurve->z_min;
272      float maxz = thisCurve->z_max;
273      int count = 1;
274      struct text_label *currentLabel;
275
276      /* GNUPlot uses these globle values in graph3d.c.  So set them here */
277      zmin = thisCurve->z_min;
278      zmax = thisCurve->z_max;
279      ymax = thisCurve->y_max;
280      ymin = thisCurve->y_min;
281
282      samples = thisCurve->samples;
283      iso_samples = thisCurve->iso_samples;
284
285      if (maxz != minz)
286      {
287         for (currentLabel = first_label; currentLabel != 0;
288              currentLabel = currentLabel->next)
289             currentLabel->x = maxx;
290
291         do_3dplot(thisCurve, count, minx, maxx, miny, maxy, minz, maxz);
292      }
293    }
294
295    
296    if (del == 1)
297    {
298       free_surface(thisCurve);
299    }
300    thisCurve = 0;
301
302
303 }
304
305
306 void ProcessNewSegments(printIndex)
307 int printIndex;
308 {
309    struct surface_points* thisCurve;
310    int allvalid = 0;
311    int i;
312    int del = 0;
313
314    for (i = 0; curves->iso_samples == nocurves && i < nocurves; i++)
315    {
316        allvalid = 1;
317        if (curves->points[i * nopoints + printIndex].valid != 1)
318        {
319           allvalid = 0;
320           break;
321        }
322    }
323   
324    if (allvalid == 1)
325    {
326       if (is_smooth == 1 && curves != 0)
327       {
328          thisCurve = (struct surface_points*)terrain_alloc(sizeof(struct surface_points));
329          if (is_med == 1)
330          {
331             smooth_med(thisCurve, curves, WIN_SIZE);
332             del = 1;
333          }
334          else
335          {
336           smooth(thisCurve, curves, WIN_SIZE, printIndex);
337             del = 1;
338          }
339       }
340       else
341          thisCurve = curves;
342
343       plot3d_lines(thisCurve, printIndex);
344       curves->lastprintIndex = printIndex;
345
346       if (del == 1)
347       {
348          free_surface(thisCurve);
349       }
350       thisCurve = 0;
351
352
353    }
354
355 }
356
357
358
359 void Graph3DSetCurveData(curveID, firstSample, numSamples, sample, startTime, x_inter, fold,
360                          color_disp, dpy, gc, rv, pixmap, W, H, win)
361 int curveID;
362 int firstSample;
363 int numSamples;
364 const float *sample;
365 float startTime;
366 float x_inter;
367 int fold;
368 int color_disp;
369 Display* dpy;
370 GC gc;
371 RValues rv;
372 Pixmap pixmap;
373 Dimension W;
374 Dimension H;
375 Window win;
376 {
377   int startIndex = getStartIndex(curveID);
378   int i = 0;
379   int decimal;
380   static int curves_ready_afterFold = 0;
381   static int firstDraw = 1;
382
383   x_interval = x_inter;
384  
385
386   if (fold)
387   {
388      curves->lastprintIndex = 0;
389      for (i = startIndex; i < startIndex + nopoints; i++)
390          curves->points[i].valid = 0;
391   
392      curves_ready_afterFold ++;    
393   }
394
395   i = 0;
396
397   while (firstSample + i < curves->samples && i < numSamples)
398   {
399       /* z - values insertion */
400       if (!isnan(sample[i]))    /* test for NaN */
401          curves->points[startIndex + firstSample + i].z = sample[i];
402       else
403          curves->points[startIndex + firstSample + i].z = 0;
404
405       if (curves->points[startIndex + firstSample + i].z > curves->z_max)
406       {   
407          curves->z_max = curves->points[startIndex + firstSample + i].z * 2;
408          decimal = checkDecimal(curves->z_max);
409          if (decimal == -1)
410             changeDecimal(0);
411          else
412             changeDecimal(decimal + 1);
413          
414          change = 1;
415       }
416    
417       curves->points[startIndex + firstSample + i].x = startTime + (firstSample + i) * 
418                                                        x_interval;
419       if (curves->points[startIndex + firstSample + i].x > curves->x_max)
420       {
421         curves->x_max *= 2;
422         change = 1;
423       }
424    
425       curves->points[startIndex + firstSample + i].valid = 1;
426  
427       if (fold == 0 && firstSample != 0)
428       {
429          if (curves->iso_samples == nocurves)
430          {
431             if (change == 1 || (startIndex + firstSample + i) % nopoints == 0 )
432             {
433                #ifndef MOTIF
434                if (color_disp) { /* Athena needs different erase for color and mono */
435                #endif
436                   XSetForeground(dpy, gc, rv.bg);
437                   XFillRectangle(dpy, pixmap, gc, 0, 0, W, H);
438                   XFillRectangle(dpy, win, gc, 0, 0, W, H);
439                   XSetForeground(dpy, gc, rv.fg);
440                   XSetBackground(dpy, gc, rv.bg);
441                #ifndef MOTIF
442                }
443                else {
444                   XSetFunction(dpy, gc, GXxor);
445                   XCopyArea(dpy, win, win, gc, 0, 0, W, H, 0, 0);
446                   XCopyArea(dpy, pixmap, pixmap, gc, 0, 0, W, H, 0, 0);
447                   XSetFunction(dpy, gc, GXcopyInverted);
448                }
449                #endif
450
451                ReDisplayGraph();
452
453                /* draw the graph on the window */
454                XClearArea(dpy, win, 0, 0, 0, 0, True);
455
456                ProcessNewSegments(firstSample + i);
457                setNotFt();
458                change = 0;
459             }
460             else
461             {
462                ProcessNewSegments(firstSample + i);
463             }
464       
465          }
466       }
467       else
468          curves->lastprintIndex = firstSample + i;
469      
470       i ++;
471   }
472
473   if ((fold == 1 && curves_ready_afterFold == nocurves) ||
474       (curves->iso_samples == nocurves && firstSample == 0 && firstDraw == 1))
475   { 
476               #ifndef MOTIF
477                if (color_disp) { /* Athena needs different erase for color and mono */
478                #endif
479                   XSetForeground(dpy, gc, rv.bg);
480                   XFillRectangle(dpy, pixmap, gc, 0, 0, W, H);
481                   XFillRectangle(dpy, win, gc, 0, 0, W, H);
482                   XSetForeground(dpy, gc, rv.fg);
483                   XSetBackground(dpy, gc, rv.bg);
484                #ifndef MOTIF
485                }
486                else {
487                   XSetFunction(dpy, gc, GXxor);
488                   XCopyArea(dpy, win, win, gc, 0, 0, W, H, 0, 0);
489                   XCopyArea(dpy, pixmap, pixmap, gc, 0, 0, W, H, 0, 0);
490                   XSetFunction(dpy, gc, GXcopyInverted);
491                }
492                #endif
493
494                ReDisplayGraph();
495
496                /* draw the graph on the window */
497                XClearArea(dpy, win, 0, 0, 0, 0, True);
498                
499                curves_ready_afterFold = 0;
500                firstDraw = 0;
501                change = 0;
502   }  
503
504   return ;
505
506 }
507
508
509 int Graph3DAddNewCurve (m_name, r_name, p_name, axis_label, groupID, no_points, 
510                         no_curves)
511 char *m_name;
512 char *r_name;
513 char *p_name;
514 char *axis_label;
515 int groupID;
516 int no_points;
517 int no_curves;
518 {
519   int i = 0;
520   float y_value;
521   int curveID;
522   struct coordinate *temp;
523   struct text_label *currentLabel;
524   
525  
526   if (curves == 0)
527   {
528     /* initialize the required value at the FIRST time */
529     nopoints = no_points;
530     nocurves = no_curves;
531
532     curves = (struct surface_points *)terrain_alloc(sizeof(struct surface_points));
533     curves->next_sp = 0;
534     curves->points = (struct coordinate *) terrain_alloc(sizeof(struct coordinate)*nopoints);
535
536     strcpy(title, "Phase: ");
537     strcpy(title + 7, p_name);
538
539     curves->title = m_name;
540     curves->line_type = 0;
541     curveID = 0;
542     curves->p_count = nopoints;
543     curves->samples = nopoints;
544     y_value = 0;
545     curves->iso_samples = 1;
546     curves->x_max = 100;
547     curves->x_min = 0;
548     curves->z_max = 0.0001;
549     curves->z_min = 0;
550     curves->y_min = 0;
551     curves->lastprintIndex = 0;
552
553     first_label = (struct text_label*)terrain_alloc(sizeof(struct text_label));
554     currentLabel = first_label;
555
556     strcpy(xlabel, "time in seconds");    
557     strcpy(zlabel, axis_label);
558
559   }
560   else
561   {
562  
563     temp = (struct coordinate*)terrain_alloc(sizeof(struct coordinate) *
564            (curves->p_count + nopoints));
565     for( i = 0; i < curves->p_count; i++)
566       temp[i] = curves->points[i];
567
568     free(curves->points);
569     curves->points = temp;
570
571     temp = 0;
572
573     curveID = curves->p_count;
574     curves->p_count += nopoints;
575     curveID = curves->iso_samples;
576     y_value = curves->y_max + y_interval;
577     curves->iso_samples++;   
578
579     currentLabel = first_label;
580     while (currentLabel->next != 0)
581           currentLabel = currentLabel->next;
582
583     currentLabel->next = (struct text_label*)terrain_alloc(sizeof(struct text_label));
584     currentLabel = currentLabel->next;
585
586
587   }
588
589   curves->y_max = y_value;
590   for (;i < curves->p_count; i++)
591   {
592      curves->points[i].y = y_value;
593      curves->points[i].valid = 0;
594   }
595
596   currentLabel->tag = curveID;
597   currentLabel->y = y_value;
598   currentLabel->z = 0;
599   currentLabel->next = 0;
600   strcpy(currentLabel->text, r_name);
601
602   return curveID;
603
604 }
605
606
607
608 /********************** modified section ends***************************
609  ***********************************************************************/
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624