home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c129 / 1.ddi / SEGRAPH.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-01-03  |  62.5 KB  |  2,222 lines
  1. #include  <string.h>
  2. #include <stdlib.h>
  3. #include <dos.h>
  4. #include <graph.h>
  5. #include <math.h >
  6. #include <stdio.h>
  7. #include <conio.h>
  8. #include "worlddr.h"
  9. #include "hpplot.h"
  10.  
  11. char stringvector[20];
  12. typedef char string80[80];
  13. typedef char string20[20];
  14.  
  15. typedef struct grstype
  16. {
  17.    struct WorldRect plotworld;
  18.    struct WorldRect plotclip;
  19.    struct WorldRect win2plotratio;
  20.    struct viewporttype plotrect;
  21.    struct viewporttype drawingrect;
  22.    char LogX;
  23.    char LogY;
  24.    int numticx;
  25.    int numticy;
  26.    float xint;
  27.    float yint;
  28.    float tsx;
  29.    float tsy;
  30.    float ticspacex;
  31.    float ticspacey;
  32. } grstype;
  33.  
  34. typedef char string256[256];
  35. grstype grstat[11];
  36. int cwin;
  37. float LogScFactors[10] = {0.0,0.3010,0.4771,0.6021,0.6990,
  38.                           0.7782,0.8451,0.9031,0.9542,1.0};
  39. float TwoPi = 6.2831854;
  40. struct WorldRect a;
  41. struct WorldRect b;
  42. struct viewporttype SeGraphWindow;
  43. float AspectRatio;
  44. int BlackAndWhite;
  45.  
  46.  
  47.  
  48. void SetWin2PlotRatio(int win, float l,float t,float r,float b)
  49. {
  50.   
  51.     grstat[win].win2plotratio.left   = l;
  52.     grstat[win].win2plotratio.right  = r;
  53.     grstat[win].win2plotratio.top    = t;
  54.     grstat[win].win2plotratio.bottom = b;
  55.  
  56.   
  57.   
  58.    grstat[win].plotrect.left  = grstat[win].drawingrect.left +
  59.            Round((grstat[win].drawingrect.right - grstat[win].drawingrect.left)
  60.            * grstat[win].win2plotratio.left);
  61.    grstat[win].plotrect.bottom= grstat[win].drawingrect.bottom -
  62.            Round((grstat[win].drawingrect.bottom - grstat[win].drawingrect.top)
  63.            * grstat[win].win2plotratio.bottom);
  64.    grstat[win].plotrect.right = grstat[win].drawingrect.right -
  65.            Round((grstat[win].drawingrect.right - grstat[win].drawingrect.left)
  66.            * grstat[win].win2plotratio.right);
  67.    grstat[win].plotrect.top   = grstat[win].drawingrect.top +
  68.            Round((grstat[win].drawingrect.bottom - grstat[win].drawingrect.top)
  69.            * grstat[win].win2plotratio.top);
  70.  }
  71.  
  72.  
  73.  
  74. void SetRect(struct viewporttype *r,int xx1,int yy1,int xx2,int yy2)
  75. {
  76.    (*r).left = xx1;
  77.    (*r).top = yy1;
  78.    (*r).right = xx2;
  79.    (*r).bottom = yy2;
  80. }
  81.  
  82.  
  83. void SetGraphAreaWorld(float a,float b,float c,float d)
  84. {
  85.  
  86.     grstat[cwin].plotworld.left = a - (c - a) *
  87.                       (grstat[cwin].win2plotratio.left/
  88.                       (1.0-(grstat[cwin].win2plotratio.left+
  89.                       grstat[cwin].win2plotratio.right)));
  90.     grstat[cwin].plotworld.bottom = b - (d - b) *
  91.                       (grstat[cwin].win2plotratio.bottom/
  92.                       (1.0-(grstat[cwin].win2plotratio.bottom+
  93.                       grstat[cwin].win2plotratio.top)));
  94.     grstat[cwin].plotworld.right = c + (c - a)*
  95.                       (grstat[cwin].win2plotratio.right/
  96.                       (1.0-(grstat[cwin].win2plotratio.right+
  97.                       grstat[cwin].win2plotratio.left)));
  98.     grstat[cwin].plotworld.top =  d + (d - b) *
  99.                       (grstat[cwin].win2plotratio.top/
  100.                       (1.0-(grstat[cwin].win2plotratio.top+
  101.                       grstat[cwin].win2plotratio.bottom)));
  102.  
  103.  
  104.         SetWorldRect(&grstat[cwin].plotclip,a,b,c,d);
  105.  
  106.     
  107. }
  108.  
  109.  
  110. void SetGraphWindow()
  111. {
  112.          SetGraphViewport(grstat[cwin].drawingrect.left,
  113.                           grstat[cwin].drawingrect.top,
  114.                           grstat[cwin].drawingrect.right,
  115.                           grstat[cwin].drawingrect.bottom);
  116. }
  117.  
  118.  
  119. void SetCurrentWindow(int win)
  120. {
  121.    cwin = win;
  122.    SetGraphWindow();
  123. }
  124.  
  125. float PowerCalc(float realnum,float power)
  126. {
  127.    float _fret;
  128.    if ( realnum < 1.0e-16 )
  129.      _fret =  0.0;
  130.    else
  131.     _fret =  pow(realnum,power);
  132.    return(_fret);
  133.  
  134. }
  135.  
  136. float log10x(float realnum)
  137. {  float _fret;
  138.  
  139.    if (realnum < 1.0e-16)
  140.      realnum = 1.0e-16;
  141.    _fret = ( float ) log10(realnum);
  142.    return(_fret);
  143. }
  144.  
  145.  
  146. float logx(float realnum)
  147. {  float _fret;
  148.    double dreal;
  149.  
  150.    if (realnum < 1.0e-16)
  151.      realnum = 1.0e-16;
  152.   _fret =  log(realnum);
  153.    return(_fret);
  154. }
  155.  
  156.  
  157. void swaps(float *x1,float *x2)
  158. {
  159.    float temp;
  160.    temp = (*x2);
  161.    (*x2) = (*x1);
  162.    (*x1) = temp;
  163. }
  164.  
  165.  
  166. int NumExp(float realnum)
  167. {
  168.    int _fret;
  169.    float sign;
  170.    _fret =  floor(log10x(fabs(realnum)));
  171.    return(_fret);
  172. }
  173.  
  174.  
  175. void FindMinMax(float  *dataset,int numdat,
  176.                 float *minval,float *maxval)
  177. {
  178.    int i;
  179.  
  180.    *minval = dataset[0];
  181.    *maxval = dataset[0];
  182.    for ( i = 0; i <= numdat - 1; i++ ) {
  183.       if ( (dataset[i]) < (*minval) ) {
  184.          (*minval) = (dataset[i]);
  185.       }
  186.       if ( (dataset[i]) > (*maxval) ) {
  187.          (*maxval) = (dataset[i]);
  188.       }
  189.    }
  190. }
  191.  
  192.  
  193. void SortData(float *x,float *y,int n,int d)
  194. {
  195.  
  196.    static int j;
  197.    float TempX;
  198.    float TempY;
  199.    int abt;
  200.    static int k;
  201.    float *TempArray;
  202.  
  203.    TempArray = (float *) calloc(n,4);
  204.  
  205.    if (n<= 1){ }
  206.    else{
  207.    for ( j=0; j <= n - 1; j++ ) {
  208.       abt = 0;
  209.       k = j - 1;
  210.       TempX = x[j];
  211.       TempY = y[j];
  212.       while ((abt==0) && (k >= 0)) {
  213.          if ( TempX < x[k] ) {
  214.             x[k + 1] = x[k];
  215.             y[k + 1] = y[k];
  216.             k = k- 1;
  217.          }
  218.         else abt = 1;
  219.       }
  220.       y[k+1]=TempY;
  221.       x[k+1]=TempX;
  222.    }
  223.  
  224.    if  (d == 0)  {
  225.       for (j=0; j<= n-1; j++){
  226.        TempArray[j] = x[j];
  227.       }
  228.       for ( j = n - 1; j >= 0; j-- ) {
  229.          x[j] = TempArray[n - 1 - j];
  230.       }
  231.       for (j=0; j<= n-1; j++){
  232.        TempArray[j] = y[j];
  233.       }
  234.       for ( j = n - 1; j >= 0; j-- ) {
  235.          y[j] = TempArray[n - 1 - j];
  236.       }
  237.    }
  238.  
  239.   }
  240.    free(TempArray);
  241. }
  242.  
  243.  
  244. void SortDataX(float *x,float *y,int n,int d)
  245. {
  246.    SortData(x,y,n,d);
  247. }
  248.  
  249. void SortDataY(float *x,float *y,int n,int d)
  250. {
  251.    SortData(y,x,n,d);
  252. }
  253.  
  254. void SetAxesType(int PlotTypeX,int PlotTypeY)
  255. {
  256.         if ( PlotTypeX == 1 ) {
  257.                 grstat[cwin].LogX = 1;
  258.          }
  259.          else {
  260.                 grstat[cwin].LogX = 0;
  261.          }
  262.          if ( PlotTypeY == 1 ) {
  263.                 grstat[cwin].LogY = 1;
  264.          }
  265.          else {
  266.                 grstat[cwin].LogY = 0;
  267.          }
  268.  
  269. }
  270.  
  271.  
  272. void DefGraphWindow(int xx1,int yy1,int xx2,int yy2,int win)
  273. {
  274.         cwin = win;
  275.         SetAxesType(0,0);
  276.         SetRect(&grstat[cwin].drawingrect,xx1,yy1,xx2,yy2);
  277.         grstat[cwin].plotrect.left  = grstat[cwin].drawingrect.left +
  278.            Round((grstat[cwin].drawingrect.right - grstat[cwin].drawingrect.left)
  279.            * grstat[cwin].win2plotratio.left);
  280.         grstat[cwin].plotrect.bottom= grstat[cwin].drawingrect.bottom -
  281.          Round((grstat[cwin].drawingrect.bottom - grstat[cwin].drawingrect.top)
  282.            * grstat[cwin].win2plotratio.bottom);
  283.         grstat[cwin].plotrect.right = grstat[cwin].drawingrect.right -
  284.           Round((grstat[cwin].drawingrect.right - grstat[cwin].drawingrect.left)
  285.            * grstat[cwin].win2plotratio.right);
  286.         grstat[cwin].plotrect.top   = grstat[cwin].drawingrect.top +
  287.             Round((grstat[cwin].drawingrect.bottom - grstat[cwin].drawingrect.top)
  288.            * grstat[cwin].win2plotratio.top);
  289.           
  290.   
  291.         SetWorldRect(&grstat[cwin].plotclip,0.0,0.0,1000.0,1000.0);
  292.         SetWorldRect(&grstat[cwin].plotworld,0.0,0.0,1000.0,1000.0);
  293.         SetGraphViewport(xx1,yy1,xx2,yy2);
  294.         SetGraphAreaWorld(0.0,0.0,1000.0,1000.0);
  295. }
  296.  
  297. void SetPercentWindow( float x1,float y1,float x2,float y2, int win )
  298. { int maxX, maxY;
  299.  
  300.   GetMaxCoords(&maxX, &maxY);
  301.   DefGraphWindow( Round(x1*maxX),Round(y1*maxY),Round(x2*maxX),Round(y2*maxY),win);
  302. }
  303.  
  304.  
  305. void BorderCurrentWindow( int c )
  306. {
  307.         SelectColor(c);
  308.         rectangleXX(1,1,
  309.              (grstat[cwin].drawingrect.right-grstat[cwin].drawingrect.left-1),
  310.                      (grstat[cwin].drawingrect.bottom-grstat[cwin].drawingrect.top-1));
  311. }
  312.  
  313. void SetViewBackground( int c )
  314. {
  315.          setfillstyleXX(1,c);
  316.          barXX(0,0,
  317.              (grstat[cwin].drawingrect.right-grstat[cwin].drawingrect.left),
  318.                      (grstat[cwin].drawingrect.bottom-grstat[cwin].drawingrect.top));
  319. }
  320.  
  321. void SetPlotBackground( int c )
  322. {
  323.          setfillstyleXX(1,c);
  324.          SetGraphViewport(grstat[cwin].plotrect.left,
  325.                            grstat[cwin].plotrect.top,
  326.                            grstat[cwin].plotrect.right,
  327.                            grstat[cwin].plotrect.bottom);
  328.            barXX(0,0,
  329.               (grstat[cwin].plotrect.right-grstat[cwin].plotrect.left),
  330.               (grstat[cwin].plotrect.bottom-grstat[cwin].plotrect.top));
  331.            SetGraphViewport(grstat[cwin].drawingrect.left,
  332.                             grstat[cwin].drawingrect.top,
  333.                             grstat[cwin].drawingrect.right,
  334.                             grstat[cwin].drawingrect.bottom);
  335.  
  336.  
  337. }
  338.  
  339.  
  340. void ScaleLogX(float xx1,float xx2)
  341. {
  342.    int ex1;
  343.    int ex2;
  344.  
  345.          xx2 = xx2 - xx2 / 10000;
  346.          ex2 = NumExp(xx2) + 1;
  347.          xx2 = PowerCalc(10,ex2);
  348.          xx1 = xx1 + xx1 / 10000.0;
  349.          ex1 = NumExp(xx1);
  350.      xx1 = PowerCalc(10,ex1) * 1.0001;
  351.          SetGraphAreaWorld(xx1,grstat[cwin].plotclip.bottom,
  352.                            xx2,grstat[cwin].plotclip.top);
  353.          grstat[cwin].LogX = 1;
  354. }
  355.  
  356.  
  357. void ScaleLogY(float yy1,float yy2)
  358. {
  359.    int ex1;
  360.    int ex2;
  361.  
  362.          yy2 = yy2 - yy2 / 10000.0;
  363.          ex2 = NumExp(yy2) + 1;
  364.          yy2 = PowerCalc(10,ex2);
  365.          yy1 = yy1 + yy1 / 10000.0;
  366.          ex1 = NumExp(yy1);
  367.      yy1 = PowerCalc(10,ex1) * 1.0001;
  368.          SetGraphAreaWorld(grstat[cwin].plotclip.left,yy1,
  369.                            grstat[cwin].plotclip.right,yy2);
  370.          grstat[cwin].LogY = 1;
  371. }
  372.  
  373.  
  374. void ScaleLinX(float xx1,float xx2)
  375. {
  376.          SetGraphAreaWorld(xx1,grstat[cwin].plotclip.bottom,
  377.                            xx2,grstat[cwin].plotclip.top);
  378.          grstat[cwin].LogX = 0;
  379. }
  380.  
  381.  
  382. void ScaleLinY(float yy1,float yy2)
  383. {
  384.          SetGraphAreaWorld(grstat[cwin].plotclip.left,yy1,
  385.                            grstat[cwin].plotclip.right,yy2);
  386.          grstat[cwin].LogY = 0;
  387. }
  388.  
  389.  
  390. void ScalePlotArea(float xx1,float yy1,float xx2,float yy2)
  391. {
  392.          if ( grstat[cwin].LogX ) {
  393.             ScaleLogX(xx1,xx2);
  394.          }
  395.          else {
  396.             ScaleLinX(xx1,xx2);
  397.          }
  398.          if ( grstat[cwin].LogY ) {
  399.             ScaleLogY(yy1,yy2);
  400.          }
  401.          else {
  402.             ScaleLinY(yy1,yy2);
  403.          }
  404. }
  405.  
  406.  
  407. void ClearWindow()
  408. {
  409.  
  410.          ClearViewportXX();
  411.  
  412. }
  413.  
  414.  
  415. void ClearGraph()
  416. {
  417.          SetGraphViewport(grstat[cwin].plotrect.left+1,
  418.                           grstat[cwin].plotrect.top+1,
  419.                           grstat[cwin].plotrect.right-1,
  420.                           grstat[cwin].plotrect.bottom-1);
  421.          ClearViewportXX();
  422.          SetGraphViewport(grstat[cwin].drawingrect.left,
  423.                           grstat[cwin].drawingrect.top,
  424.                           grstat[cwin].drawingrect.right,
  425.                           grstat[cwin].drawingrect.bottom);
  426. }
  427.  
  428.  
  429. void SetXYIntercepts(float xx1,float yy1)
  430. {
  431.          grstat[cwin].xint = xx1;
  432.          grstat[cwin].yint = yy1;
  433. }
  434.  
  435.  
  436. void DrawTicX(float x,float y,float l)
  437. {
  438.         if ( (x <= grstat[cwin].plotclip.right) && (x >= grstat[cwin].plotclip.left) ) {
  439.                 MoveWorldAbs(x,y);
  440.                 LineWorldAbs(x,y - l);
  441.         }
  442. }
  443.  
  444. void DrawTicY(float x,float y,float l)
  445. {
  446.       if ( (y <= grstat[cwin].plotclip.top) && (y >= grstat[cwin].plotclip.bottom) ) {
  447.                MoveWorldAbs(x,y);
  448.                LineWorldAbs(x - l,y);
  449.       }
  450. }
  451.  
  452. void DrLogXAx(int dir)
  453. {
  454.    float tl1;
  455.    float tl2;
  456.    float xx1;
  457.    float yy1;
  458.    float ticlen;
  459.    int i;
  460.    int j;
  461.    int XLogMin;
  462.    int XLogMax;
  463.    float mts;
  464.  
  465.         SetWorldCoordinates(grstat[cwin].plotworld.left,
  466.                              grstat[cwin].plotworld.bottom,
  467.                              grstat[cwin].plotworld.right,
  468.                              grstat[cwin].plotworld.top);
  469.          MoveWorldAbs(grstat[cwin].plotclip.left,grstat[cwin].plotclip.bottom);
  470.          LineWorldAbs(grstat[cwin].plotclip.right,grstat[cwin].plotclip.bottom);
  471.          XLogMin = NumExp(grstat[cwin].plotclip.left);
  472.          XLogMax = NumExp(grstat[cwin].plotclip.right);
  473.          grstat[cwin].numticx = XLogMax - XLogMin;
  474.          mts = (grstat[cwin].plotclip.right - grstat[cwin].plotclip.left)
  475.                     / grstat[cwin].numticx;
  476.          grstat[cwin].ticspacex = mts;
  477.          tl1 = 0.015 * (grstat[cwin].plotclip.top - grstat[cwin].plotclip.bottom);
  478.          tl2 = 2 * tl1;
  479.          for ( i = 0; i <= grstat[cwin].numticx - 1; i++ ) {
  480.                 for ( j = 1; j <= 10; j++ ) {
  481.                         xx1 = grstat[cwin].plotclip.left + i * mts
  482.                             + LogScFactors[j] * mts;
  483.                        yy1 = grstat[cwin].plotclip.bottom;
  484.                        if ( (j % 9) == 1 ) {
  485.                           ticlen = tl2;
  486.                        }
  487.                        else {
  488.                           ticlen = tl1;
  489.                         }
  490.                         if ( dir == 1 ) {
  491.                                 ticlen = -ticlen;
  492.                         }
  493.                         DrawTicX(xx1,yy1,ticlen);
  494.                 }
  495.          }
  496. }
  497.  
  498. void DrLogYAx(int dir)
  499. {
  500.    float tl1;
  501.    float tl2;
  502.    float xx1;
  503.    float yy1;
  504.    float ticlen;
  505.    int i;
  506.    int j;
  507.    int YLogMin;
  508.    int YLogMax;
  509.    float mts;
  510.  
  511.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  512.                              grstat[cwin].plotworld.bottom,
  513.                              grstat[cwin].plotworld.right,
  514.                              grstat[cwin].plotworld.top);
  515.          MoveWorldAbs(grstat[cwin].plotclip.left,grstat[cwin].plotclip.bottom);
  516.          LineWorldAbs(grstat[cwin].plotclip.left,grstat[cwin].plotclip.top);
  517.          YLogMin = NumExp(grstat[cwin].plotclip.bottom);
  518.          YLogMax = NumExp(grstat[cwin].plotclip.top);
  519.          grstat[cwin].numticy = YLogMax - YLogMin;
  520.          mts = (grstat[cwin].plotclip.top - grstat[cwin].plotclip.bottom)/
  521.                 grstat[cwin].numticy;
  522.          grstat[cwin].ticspacey = mts;
  523.          tl1 = 0.010 * (grstat[cwin].plotclip.right - grstat[cwin].plotclip.left);
  524.          tl2 = 2 * tl1;
  525.          for ( i = 0; i <= grstat[cwin].numticy - 1; i++ ) {
  526.             for ( j = 1; j <= 10; j++ ) {
  527.                yy1 = grstat[cwin].plotclip.bottom + i * mts + LogScFactors[j - 1] * mts;
  528.                xx1 = grstat[cwin].plotclip.left;
  529.                if ( (j % 9) == 1 ) {
  530.                   ticlen = tl2;
  531.                }
  532.                else {
  533.                   ticlen = tl1;
  534.                }
  535.                if ( dir == 1 ) {
  536.                   ticlen = -ticlen;
  537.                }
  538.                DrawTicY(xx1,yy1,ticlen);
  539.             }
  540.          }
  541.  
  542. }
  543.  
  544. void DrLinXAx(float TicSpace,int dir)
  545. {
  546.    float tl;
  547.    float mts;
  548.    float xx1;
  549.    float yy1;
  550.    float ticlen;
  551.    int c;
  552.    int i;
  553.    int j;
  554.  
  555.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  556.                              grstat[cwin].plotworld.bottom,
  557.                              grstat[cwin].plotworld.right,
  558.                              grstat[cwin].plotworld.top);
  559.  
  560.          MoveWorldAbs(grstat[cwin].plotclip.left,grstat[cwin].yint);
  561.          LineWorldAbs(grstat[cwin].plotclip.right,grstat[cwin].yint);
  562.          grstat[cwin].numticx = Round((grstat[cwin].plotclip.right - grstat[cwin].plotclip.left)
  563.                                      / TicSpace);
  564.          grstat[cwin].ticspacex = TicSpace;
  565.          xx1 = grstat[cwin].xint + grstat[cwin].ticspacex;
  566.          tl = 0.015 * (grstat[cwin].plotclip.top - grstat[cwin].plotclip.bottom);
  567.          if ( dir == 0 ) {
  568.             ticlen = tl;
  569.          }
  570.          else {
  571.             ticlen = -tl;
  572.          }
  573.          while ( xx1 <= grstat[cwin].plotclip.right ) {
  574.             DrawTicX(xx1,grstat[cwin].yint,ticlen);
  575.             xx1 = xx1 + grstat[cwin].ticspacex;
  576.          }
  577.          xx1 = grstat[cwin].xint - grstat[cwin].ticspacex;
  578.          while ( xx1 >= grstat[cwin].plotclip.left ) {
  579.             DrawTicX(xx1,grstat[cwin].yint,ticlen);
  580.             xx1 = xx1 - grstat[cwin].ticspacex;
  581.          }
  582.  
  583. }
  584.  
  585. void DrLinYAx(float TicSpace,int dir)
  586. {
  587.    float tl;
  588.    float mts;
  589.    float xx1;
  590.    float yy1;
  591.    float ticlen;
  592.    int i;
  593.    int j;
  594.  
  595.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  596.                              grstat[cwin].plotworld.bottom,
  597.                              grstat[cwin].plotworld.right,
  598.                              grstat[cwin].plotworld.top);
  599.          MoveWorldAbs(grstat[cwin].xint,grstat[cwin].plotclip.bottom);
  600.          LineWorldAbs(grstat[cwin].xint,grstat[cwin].plotclip.top);
  601.          grstat[cwin].numticy = Round((grstat[cwin].plotclip.top - grstat[cwin].plotclip.bottom) / TicSpace);
  602.          grstat[cwin].ticspacey = TicSpace;
  603.          yy1 = grstat[cwin].yint + grstat[cwin].ticspacey;
  604.          tl = 0.01 * (grstat[cwin].plotclip.right - grstat[cwin].plotclip.left);
  605.          if ( dir == 0 ) {
  606.             ticlen = tl;
  607.          }
  608.          else {
  609.             ticlen = -tl;
  610.          }
  611.          while ( yy1 <= grstat[cwin].plotclip.top ) {
  612.             DrawTicY(grstat[cwin].xint,yy1,ticlen);
  613.             yy1 = yy1 + grstat[cwin].ticspacey;
  614.          }
  615.          yy1 = grstat[cwin].yint - grstat[cwin].ticspacey;
  616.          while ( yy1 >= grstat[cwin].plotclip.bottom ) {
  617.             DrawTicY(grstat[cwin].xint,yy1,ticlen);
  618.             yy1 = yy1 - grstat[cwin].ticspacey;
  619.          }
  620.  
  621. }
  622.  
  623. void DrawXAxis(float TicSpace,int dir)
  624. {
  625.         SetWorldCoordinates(grstat[cwin].plotworld.left,
  626.                              grstat[cwin].plotworld.bottom,
  627.                              grstat[cwin].plotworld.right,
  628.                              grstat[cwin].plotworld.top);
  629.         if ( grstat[cwin].LogX ) {
  630.             DrLogXAx(dir);
  631.          }
  632.          else {
  633.             DrLinXAx(TicSpace,dir);
  634.          }
  635.  
  636. }
  637.  
  638. void DrawYAxis(float TicSpace,int dir)
  639. {
  640.         SetWorldCoordinates(grstat[cwin].plotworld.left,
  641.                             grstat[cwin].plotworld.bottom,
  642.                             grstat[cwin].plotworld.right,
  643.                             grstat[cwin].plotworld.top);
  644.  
  645.          if ( grstat[cwin].LogY ) {
  646.                 DrLogYAx(dir);
  647.          }
  648.          else {
  649.                 DrLinYAx(TicSpace,dir);
  650.          }
  651.  
  652. }
  653.  
  654. void ConvertNum(float innum,float a1,float a2,float TicSpace,
  655.                 char LogFlag, char *outstr)
  656. {
  657.    int n1;
  658.    int n2;
  659.    float range;
  660.    char abbrev[2];
  661.  
  662.    if ( LogFlag ) {
  663.         n2 = NumExp(innum);
  664.         n1 = NumExp(innum);
  665.    }
  666.    else {
  667.         if ( fabs(a2) >= fabs(a1) ) {
  668.                 n1 = NumExp(a2);
  669.         }
  670.         else {
  671.                 n1 = NumExp(a1);
  672.         }
  673.         n2 = NumExp(TicSpace) - 1;
  674.    }
  675.    switch ( n1 ) {
  676.         case -1:
  677.         case -2:
  678.         case -3:
  679.         case -4:
  680.         {
  681.                 if ( n2 < 0 ) {
  682.                         n2 = -n2;
  683.                 }
  684.                 else {
  685.                         n2 = 0;
  686.                 }
  687.                 sprintf(outstr, "%*.*f", 1,n2,innum);
  688.         }
  689.         break;
  690.         case 0:
  691.         case 1:
  692.         case 2:
  693.         {
  694.                 if ( n2 < 0 ) {
  695.                         n2 = -n2;
  696.                 }
  697.                 else {
  698.                         n2 = 0;
  699.                 }
  700.                 sprintf(outstr, "%*.*f", 1, n2,innum);
  701.         }
  702.         break;
  703.         case 3:
  704.         case 4:
  705.         case 5:
  706.         {
  707.                 innum = innum / 1000.0;
  708.                 n1 = n1 - 3;
  709.                 n2 = n2 - 3;
  710.                 if ( n2 < 0 ) {
  711.                         n2 = -n2;
  712.                 }
  713.                 else {
  714.                         n2 = 0;
  715.         }
  716.         sprintf(outstr, "%*.*f", 1,n2,innum);
  717.         strcpy(abbrev,"K");
  718.         strcat(outstr,abbrev);
  719.         }
  720.         break;
  721.         case 6:
  722.         case 7:
  723.         case 8:
  724.         {
  725.                 innum = innum / 1000000.0;
  726.                 n1 = n1 - 6;
  727.                 n2 = n2 - 6;
  728.                 if ( n2 < 0 ) {
  729.                         n2 = -n2;
  730.                 }
  731.                 else {
  732.                         n2 = 0;
  733.                 }
  734.                 sprintf(outstr, "%*.*f",1,n2, innum);
  735.                 strcpy(abbrev,"M");
  736.                 strcat(outstr,abbrev);
  737.         }
  738.         break;
  739.         case 9:
  740.         case 10:
  741.         case 11:
  742.         {
  743.                 innum = innum / 1000000000.0;
  744.                 n1 = n1 - 9;
  745.                 n2 = n2 - 9;
  746.                 if ( n2 < 0 ) {
  747.                         n2 = -n2;
  748.                 }
  749.                 else {
  750.                         n2 = 0;
  751.                 }
  752.                 sprintf(outstr, "%*.*f",1,n2, innum);
  753.                 strcpy(abbrev,"B");
  754.                 strcat(outstr,abbrev);
  755.                
  756.         }
  757.         break;
  758.         default:
  759.          {
  760.                 sprintf(outstr, "%*.*e", 1,n2,innum);
  761.          }
  762.          break;
  763.         }
  764. }
  765. void LabelTicYString(float xx,float yy,char *TicLabel,int dir)
  766. {
  767.    float tl=11;
  768.    float xx1;
  769.    float yy1;
  770.    float h;
  771.    float w;
  772.  
  773.       if ( ((yy <= grstat[cwin].plotclip.top) && (yy >= grstat[cwin].plotclip.bottom)) ) {
  774.          tl = 0.015 * (grstat[cwin].plotclip.right - grstat[cwin].plotclip.left);
  775.          if ( dir == 0 ) {
  776.             DrawTicY(xx,yy,tl);
  777.          }
  778.          else {
  779.             DrawTicY(xx,yy,-tl);
  780.          }
  781.          tl = 0.020 * (grstat[cwin].plotclip.right - grstat[cwin].plotclip.left);
  782.          yy1 = yy;
  783.          if ( dir == 0 ) {
  784.             xx1 = xx - tl;
  785.          }
  786.          else {
  787.             xx1 = xx + tl;
  788.          }
  789.          MoveWorldAbs( xx1, yy1 );
  790.          outtextXX(TicLabel);
  791.       }
  792. }
  793.  
  794. void LabelTicY(float x,float y,float yval,char lf,int dir)
  795. {
  796.    char labvalstr[32];
  797.  
  798.  
  799.          ConvertNum(yval,grstat[cwin].plotclip.bottom,grstat[cwin].plotclip.top,
  800.                     grstat[cwin].tsy,lf,labvalstr);
  801.          LabelTicYString(x,y,labvalstr,dir);
  802.  
  803. }
  804.  
  805. void LabLinYAx(int nthtic,int dir)
  806. {
  807.    float yy1;
  808.  
  809.          grstat[cwin].tsy = grstat[cwin].ticspacey * nthtic;
  810.          yy1 = grstat[cwin].yint;
  811.          if (dir==0){
  812.            if (grstat[cwin].xint != grstat[cwin].plotclip.left)  
  813.              yy1 += grstat[cwin].tsy;
  814.          }
  815.          else
  816.            if (grstat[cwin].xint != grstat[cwin].plotclip.right) 
  817.               yy1 += grstat[cwin].tsy;
  818.  
  819.          while ( yy1 <= grstat[cwin].plotclip.top ) {
  820.             LabelTicY(grstat[cwin].xint,yy1,yy1,0,dir);
  821.             yy1 = yy1 + grstat[cwin].tsy;
  822.          }
  823.          yy1 = grstat[cwin].yint - grstat[cwin].tsy;
  824.          while ( yy1 >= grstat[cwin].plotclip.bottom ) {
  825.             LabelTicY(grstat[cwin].xint,yy1,yy1,0,dir);
  826.             yy1 = yy1 - grstat[cwin].tsy;
  827.          }
  828. }
  829.  
  830. void LabelTicXString(float x,float y,char *TicLabel,int dir)
  831. {
  832.    float tl;
  833.    float xx1;
  834.    float yy1;
  835.  
  836.         if ( (x <= grstat[cwin].plotclip.right) &&
  837.            (x >= grstat[cwin].plotclip.left) ) {
  838.                 tl = 0.030 * (grstat[cwin].plotclip.top -
  839.                               grstat[cwin].plotclip.bottom);
  840.                 if ( dir == 0 ) {
  841.                         DrawTicX(x,y,tl);
  842.                 }
  843.                 else {
  844.                         DrawTicX(x,y,-tl);
  845.                 }
  846.                 tl = 0.035 * (grstat[cwin].plotclip.top -
  847.                               grstat[cwin].plotclip.bottom);
  848.                 if ( dir == 0 ) {
  849.                         yy1 = y - tl;
  850.                 }
  851.                 else {
  852.                         yy1 = y + tl;
  853.                 }
  854.                 xx1 = x;
  855.                 MoveWorldAbs( xx1, yy1 );
  856.                 outtextXX(TicLabel);
  857.       }
  858. }
  859.  
  860. void LabelTicX(float x,float y,float xval,char lf,int dir)
  861. {
  862.    char labvalstr[32];
  863.  
  864.          ConvertNum(xval,grstat[cwin].plotclip.left,grstat[cwin].plotclip.right,
  865.                     grstat[cwin].tsx,lf,labvalstr);
  866.          LabelTicXString(x,y,labvalstr,dir);
  867.  
  868. }
  869.  
  870. void LabelXAxWithStrings(int NthTic,string80 *TicStrings,int NumStrings,int dir)
  871. {
  872.    float xx1;
  873.    int i;
  874.          if ( dir == 0 ) {
  875.              settextjustifyXX(CENTER_TEXT,TOP_TEXT);
  876.          }
  877.          else {
  878.             settextjustifyXX(CENTER_TEXT,BOTTOM_TEXT);
  879.          }
  880.  
  881.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  882.                              grstat[cwin].plotworld.bottom,
  883.                              grstat[cwin].plotworld.right,
  884.                              grstat[cwin].plotworld.top);
  885.          grstat[cwin].tsx = grstat[cwin].ticspacex * NthTic;
  886.   /*       xx1 = grstat[cwin].plotclip.left + grstat[cwin].tsx;
  887.  */        xx1 = grstat[cwin].xint;
  888.          if (dir == 0){
  889.            if (grstat[cwin].yint != grstat[cwin].plotclip.bottom)
  890.              xx1 += grstat[cwin].tsx;
  891.          }
  892.          else
  893.            if (grstat[cwin].yint !=  grstat[cwin].plotclip.top )
  894.              xx1 +=  grstat[cwin].tsx;
  895.  
  896.          for ( i = 0; i <= NumStrings - 1; i++ ) {
  897.                 LabelTicXString(xx1,grstat[cwin].yint,TicStrings[i],dir);
  898.                 xx1 = xx1 + grstat[cwin].tsx;
  899.          }
  900.          settextjustifyXX( LEFT_TEXT, CENTER_TEXT );
  901.  
  902. }
  903.  
  904. void LabLinXAx(int NthTic,int dir)
  905. {
  906.    float xx1;
  907.  
  908.          grstat[cwin].tsx = grstat[cwin].ticspacex * NthTic;
  909.          xx1 = grstat[cwin].xint;
  910.          if (dir == 0){
  911.            if (grstat[cwin].yint != grstat[cwin].plotclip.bottom)
  912.              xx1 += grstat[cwin].tsx;
  913.          }
  914.          else
  915.            if (grstat[cwin].yint !=  grstat[cwin].plotclip.top )
  916.              xx1 +=  grstat[cwin].tsx;
  917.  
  918.     
  919.          while ( xx1 <= grstat[cwin].plotclip.right ) {
  920.                 LabelTicX(xx1,grstat[cwin].yint,xx1,0,dir);
  921.                 xx1 = xx1 + grstat[cwin].tsx;
  922.          }
  923.          xx1 = grstat[cwin].xint - grstat[cwin].tsx;
  924.          while ( xx1 >= grstat[cwin].plotclip.left ) {
  925.                 LabelTicX(xx1,grstat[cwin].yint,xx1,0,dir);
  926.                 xx1 = xx1 - grstat[cwin].tsx;
  927.          }
  928.  
  929. }
  930.  
  931. void LabLogYAx(int dir)
  932. {
  933.    int i;
  934.    float yy1;
  935.    float labval;
  936.          grstat[cwin].tsy = grstat[cwin].ticspacey;
  937.          for ( i = 0; i <= grstat[cwin].numticy; i++ ) {
  938.             yy1 = grstat[cwin].plotclip.bottom + i * grstat[cwin].tsy;
  939.             labval = grstat[cwin].plotclip.bottom * PowerCalc(10,i);
  940.             LabelTicY(grstat[cwin].xint,yy1,labval,1,dir);
  941.          }
  942.  
  943. }
  944.  
  945. void LabLogXAx(int dir)
  946. {
  947.    int i;
  948.    float xx1;
  949.    float labval;
  950.  
  951.          grstat[cwin].tsx = grstat[cwin].ticspacex;
  952.          for ( i = 0; i <= grstat[cwin].numticx; i++ ) {
  953.                 xx1 = grstat[cwin].plotclip.left + i * grstat[cwin].tsx;
  954.                 labval = grstat[cwin].plotclip.left * PowerCalc(10,i);
  955.                 LabelTicX(xx1,grstat[cwin].yint,labval,1,dir);
  956.          }
  957.  
  958. }
  959.  
  960. void LabelXAxis(int NthTic,int dir)
  961. {
  962.  
  963.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  964.                              grstat[cwin].plotworld.bottom,
  965.                              grstat[cwin].plotworld.right,
  966.                              grstat[cwin].plotworld.top);
  967.          if ( dir == 0 ) {
  968.             settextjustifyXX(CENTER_TEXT,TOP_TEXT);
  969.          }
  970.          else {
  971.             settextjustifyXX(CENTER_TEXT,BOTTOM_TEXT);
  972.          }
  973.          if ( grstat[cwin].LogX ) {
  974.             LabLogXAx(dir);
  975.          }
  976.          else {
  977.             LabLinXAx(NthTic,dir);
  978.          }
  979.          settextjustifyXX(LEFT_TEXT,CENTER_TEXT);
  980.  
  981.  
  982. }
  983.  
  984.  
  985. void LabelYAxis(int NthTic,int dir)
  986. {
  987.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  988.                              grstat[cwin].plotworld.bottom,
  989.                              grstat[cwin].plotworld.right,
  990.                              grstat[cwin].plotworld.top);
  991.  
  992.          if ( dir == 0 ) {
  993.             settextjustifyXX(RIGHT_TEXT,CENTER_TEXT);
  994.          }
  995.          else {
  996.             settextjustifyXX(LEFT_TEXT, CENTER_TEXT);
  997.          }
  998.          if ( grstat[cwin].LogY ) {
  999.             LabLogYAx(dir);
  1000.          }
  1001.          else {
  1002.             LabLinYAx(NthTic,dir);
  1003.          }
  1004.  
  1005.  
  1006.         settextjustifyXX(LEFT_TEXT,CENTER_TEXT);
  1007.  
  1008. }
  1009.  
  1010. void DrXLinGrid(int NthTic)
  1011. {
  1012.    float xx1;
  1013.    float xx2;
  1014.    float yy1;
  1015.    float yy2;
  1016.  
  1017.          grstat[cwin].tsx = grstat[cwin].ticspacex * NthTic;
  1018.          xx1 = grstat[cwin].xint + grstat[cwin].tsx;
  1019.          yy1 = grstat[cwin].plotclip.bottom;
  1020.          yy2 = grstat[cwin].plotclip.top;
  1021.          while ( xx1 <= grstat[cwin].plotclip.right ) {
  1022.             MoveWorldAbs(xx1,yy1);
  1023.             LineWorldAbs(xx1,yy2);
  1024.             xx1 = xx1 + grstat[cwin].tsx;
  1025.          }
  1026.          xx1 = grstat[cwin].xint - grstat[cwin].tsx;
  1027.          while ( xx1 >= grstat[cwin].plotclip.left ) {
  1028.             MoveWorldAbs(xx1,yy1);
  1029.             LineWorldAbs(xx1,yy2);
  1030.             xx1 = xx1 - grstat[cwin].tsx;
  1031.          }
  1032.  
  1033. }
  1034.  
  1035. void DrYLinGrid(int NthTic)
  1036. {
  1037.    float xx1;
  1038.    float xx2;
  1039.    float yy1;
  1040.    float yy2;
  1041.  
  1042.          grstat[cwin].tsy = grstat[cwin].ticspacey * NthTic;
  1043.          xx1 = grstat[cwin].plotclip.left;
  1044.          xx2 = grstat[cwin].plotclip.right;
  1045.          yy1 = grstat[cwin].yint + grstat[cwin].tsy;
  1046.          while ( yy1 <= grstat[cwin].plotclip.top ) {
  1047.                 MoveWorldAbs(xx1,yy1);
  1048.                 LineWorldAbs(xx2,yy1);
  1049.                 yy1 = yy1 + grstat[cwin].tsy;
  1050.          }
  1051.          yy1 = grstat[cwin].yint - grstat[cwin].tsy;
  1052.          while ( yy1 >= grstat[cwin].plotclip.bottom ) {
  1053.                 MoveWorldAbs(xx1,yy1);
  1054.                 LineWorldAbs(xx2,yy1);
  1055.                 yy1 = yy1 - grstat[cwin].tsy;
  1056.          }
  1057.  
  1058. }
  1059.  
  1060. void DrYLogGrid(int NthTic)
  1061. {
  1062.    int i;
  1063.    float xx1;
  1064.    float xx2;
  1065.    float yy1;
  1066.  
  1067.          xx1 = grstat[cwin].plotclip.left;
  1068.          xx2 = grstat[cwin].plotclip.right;
  1069.          grstat[cwin].tsy = grstat[cwin].ticspacey * NthTic;
  1070.          yy1 = grstat[cwin].yint + grstat[cwin].tsy;
  1071.          for ( i = 0; i <= grstat[cwin].numticy - 1; i++ ) {
  1072.             MoveWorldAbs(xx1,yy1);
  1073.             LineWorldAbs(xx2,yy1);
  1074.             yy1 = yy1 + grstat[cwin].tsy;
  1075.          }
  1076.  
  1077. }
  1078.  
  1079. void DrXLogGrid(int NthTic)
  1080. {
  1081.    int i;
  1082.    float xx1;
  1083.    float yy1;
  1084.    float yy2;
  1085.  
  1086.          yy1 = grstat[cwin].plotclip.bottom;
  1087.          yy2 = grstat[cwin].plotclip.top;
  1088.          grstat[cwin].tsx = grstat[cwin].ticspacex * NthTic;
  1089.          xx1 = grstat[cwin].xint + grstat[cwin].tsx;
  1090.          for ( i = 0; i <= grstat[cwin].numticx - 1; i++ ) {
  1091.             MoveWorldAbs(xx1,yy1);
  1092.             LineWorldAbs(xx1,yy2);
  1093.             xx1 = xx1 + grstat[cwin].tsx;
  1094.          }
  1095.  
  1096. }
  1097.  
  1098. void DrawGridX(int NthTic)
  1099. {
  1100.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  1101.                              grstat[cwin].plotworld.bottom,
  1102.                              grstat[cwin].plotworld.right,
  1103.                              grstat[cwin].plotworld.top);
  1104.  
  1105.         if ( grstat[cwin].LogX ) {
  1106.             DrXLogGrid(NthTic);
  1107.          }
  1108.          else {
  1109.             DrXLinGrid(NthTic);
  1110.          }
  1111.  
  1112. }
  1113.  
  1114. void DrawGridY(int NthTic)
  1115. {
  1116.         SetWorldCoordinates(grstat[cwin].plotworld.left,
  1117.                             grstat[cwin].plotworld.bottom,
  1118.                             grstat[cwin].plotworld.right,
  1119.                             grstat[cwin].plotworld.top);
  1120.  
  1121.         if ( grstat[cwin].LogY ) {
  1122.            DrYLogGrid(NthTic);
  1123.         }
  1124.         else {
  1125.            DrYLinGrid(NthTic);
  1126.         }
  1127. }
  1128.  
  1129. void DrawGrid(int NthTic)
  1130. {
  1131.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  1132.                              grstat[cwin].plotworld.bottom,
  1133.                              grstat[cwin].plotworld.right,
  1134.                              grstat[cwin].plotworld.top);
  1135.  
  1136.          if ( grstat[cwin].LogX ) {
  1137.             DrXLogGrid(NthTic);
  1138.          }
  1139.          else {
  1140.             DrXLinGrid(NthTic);
  1141.          }
  1142.          if ( grstat[cwin].LogY ) {
  1143.             DrYLogGrid(NthTic);
  1144.          }
  1145.          else {
  1146.             DrYLinGrid(NthTic);
  1147.          }
  1148. }
  1149.  
  1150. void RoundAxes(float *a1,float *a2,float *tics)
  1151. {
  1152.    float dr1;
  1153.    float dr2;
  1154.    float px2;
  1155.    float pc2;
  1156.    int di1;
  1157.    int di2;
  1158.    int digits;
  1159.  
  1160.    if (NumExp(*a2) > NumExp(*a1)) {
  1161.     px2 = NumExp(*a2) - 1;
  1162.    }
  1163.    else {
  1164.      px2 = NumExp(*a1) - 1;
  1165.    }
  1166.    pc2 = PowerCalc(10.0,px2);
  1167.    dr2 = (*a2) / pc2;
  1168.    dr1 = (*a1) / pc2;
  1169.  
  1170.    di2 = ceil(dr2 + 0.000001+(dr2-dr1)*0.05);
  1171.    if ((di2 > 0) && (dr2 <= 0.0)) di2 = 0;
  1172.  
  1173.    di1 = floor(dr1 -0.000001- (dr2-dr1)*0.05);
  1174.    if ((di1 < 0) && (dr1 >= 0.0)) di1 = 0;
  1175.  
  1176.    if ( abs(di2) < 20 ) {
  1177.         di2 = di2;
  1178.    }
  1179.    else {
  1180.         if ( abs(di2) < 60 ) {
  1181.                 di2 = ((di2 / 5)+1 ) * 5;
  1182.       }
  1183.       else {
  1184.          if ( abs(di2) < 100 ) {
  1185.                 di2 = ((di2 / 10)+1) * 10;
  1186.          }
  1187.          else {
  1188.                 di2 = ((di2 / 10)+1) * 10;
  1189.          }
  1190.       }
  1191.    }
  1192.    if ( abs(di1) < 10 ) {
  1193.         di1 = di1;
  1194.    }
  1195.    else {
  1196.         if ( abs(di1) < 60 ) {
  1197.                 di1 = ((di1 / 5)) * 5;
  1198.       }
  1199.       else {
  1200.          if ( abs(di1) < 100 ) {
  1201.                 di1 = ((di1 / 10) ) * 10;
  1202.          }
  1203.          else {
  1204.                 di1 = ((di1 / 10) ) * 10;
  1205.          }
  1206.       }
  1207.    }
  1208.    (*a1) = di1 * pc2;
  1209.    (*a2) = di2 * pc2;
  1210.    digits = abs(di2 - di1);
  1211.    if ( digits < 10 ) {
  1212.       (*tics) = (digits) / 5.0;
  1213.    }
  1214.    else {
  1215.       if ( digits < 20 ) {
  1216.          (*tics) = 2.0;
  1217.       }
  1218.       else {
  1219.          if ( digits < 50 ) {
  1220.             (*tics) = 5.0;
  1221.          }
  1222.          else {
  1223.             if ( digits < 80 ) {
  1224.                (*tics) = 10.0;
  1225.             }
  1226.             else {
  1227.                if ( digits < 100 ) {
  1228.                   (*tics) = 20.0;
  1229.                }
  1230.                else {
  1231.                   if ( digits < 151 ) {
  1232.                      (*tics) = 20.0;
  1233.                   }
  1234.                   else {
  1235.                      if ( digits < 200 ) {
  1236.                         (*tics) = 50.0;
  1237.                      }
  1238.                      else {
  1239.                         (*tics) = 100.0;
  1240.                      }
  1241.                   }
  1242.                }
  1243.             }
  1244.          }
  1245.       }
  1246.    }
  1247.    (*tics) = (*tics) * (pc2) / 10.0;
  1248. }
  1249.  
  1250.  
  1251. void AutoAxes(float *datasetx,float *datasety,int numdat,int AxFlag)
  1252. {
  1253.    # define VerySmall 1.0e-10
  1254.    float xx1;
  1255.    float yy1;
  1256.    float xx2;
  1257.    float yy2;
  1258.    float ts1;
  1259.    float ts2;
  1260.    float xi;
  1261.    float yi;
  1262.    int dirx;
  1263.    int diry;
  1264.    int lsx;
  1265.    int lsy;
  1266.  
  1267.  
  1268.          dirx = 0;
  1269.          diry = 0;
  1270.          FindMinMax(datasetx,numdat,&xx1,&xx2);
  1271.          FindMinMax(datasety,numdat,&yy1,&yy2);
  1272.          if (!( grstat[cwin].LogX )) {
  1273.            RoundAxes(&xx1,&xx2,&ts1);
  1274.          }
  1275.          if (!( grstat[cwin].LogY )) {
  1276.            RoundAxes(&yy1,&yy2,&ts2);
  1277.          }
  1278.          if ( AxFlag == 0 ) {
  1279.            if (!( grstat[cwin].LogX )) {
  1280.              if ( (xx2 >= 0.0) && (xx1 >= 0.0) ) {
  1281.                 xi = xx1;
  1282.              }
  1283.              if ( (xx2 >= 0.0) && (xx1 < 0.0) ) {
  1284.                 xi = 0.0;
  1285.              }
  1286.              if ( (xx2 <= 0.0) && (xx1 <= 0.0) ) {
  1287.                 xi = xx2;
  1288.                 diry = 1;
  1289.              }
  1290.            }
  1291.            if (!( grstat[cwin].LogY )) {
  1292.             if ( (yy2 >= 0.0) && (yy1 >= 0.0) ) {
  1293.                yi = yy1;
  1294.             }
  1295.             if ( (yy2 >= 0.0) && (yy1 < 0.0) ) {
  1296.                yi = 0.0;
  1297.             }
  1298.             if ( (yy2 <= 0.0) && (yy1 <= 0.0) ) {
  1299.                yi = yy2;
  1300.                dirx = 1;
  1301.             }
  1302.           }
  1303.          }
  1304.          else {
  1305.             xi = xx1;
  1306.             yi = yy1;
  1307.          }
  1308.          grstat[cwin].yint = yi;
  1309.          grstat[cwin].xint = xi;
  1310.          if ( grstat[cwin].LogX ) {
  1311.            grstat[cwin].xint = xx1;
  1312.          }
  1313.          if ( grstat[cwin].LogY ) {
  1314.             grstat[cwin].yint = yy1;
  1315.          }
  1316.          ScalePlotArea(xx1,yy1,xx2,yy2);
  1317.          SetXYIntercepts(grstat[cwin].xint,grstat[cwin].yint);
  1318.          DrawYAxis(ts2,diry);
  1319.          DrawXAxis(ts1,dirx);
  1320.          lsy = 10;
  1321.          if ((grstat[cwin].plotrect.right-grstat[cwin].plotrect.left) > 400) {
  1322.            lsx = 10;
  1323.          }
  1324.          else  {
  1325.           lsx = 20;
  1326.          }
  1327.          LabelYAxis(lsy,diry);
  1328.          LabelXAxis(lsx,dirx);
  1329. }
  1330.  
  1331. void PrePlot(float *datasetx,float *datasety,int numdat)
  1332. {
  1333.    int i;
  1334.    float xx1;
  1335.    float yy1;
  1336.    float xx2;
  1337.    float yy2;
  1338.    struct WorldRect wr;
  1339.  
  1340.          a = grstat[cwin].plotworld;
  1341.          b = grstat[cwin].plotclip;
  1342.          if ( grstat[cwin].LogX ) {
  1343.             xx1 = log10(grstat[cwin].plotclip.left);
  1344.             xx2 = log10(grstat[cwin].plotclip.right);
  1345.             for ( i = 0; i <= numdat - 1; i++ ) {
  1346.                datasetx[i] = log10(datasetx[i]);
  1347.             }
  1348.          }
  1349.          else {
  1350.             xx1 = grstat[cwin].plotclip.left;
  1351.             xx2 = grstat[cwin].plotclip.right;
  1352.          }
  1353.          if ( grstat[cwin].LogY ) {
  1354.             yy1 = log10(grstat[cwin].plotclip.bottom);
  1355.             yy2 = log10(grstat[cwin].plotclip.top);
  1356.             for ( i = 0; i <= numdat - 1; i++ ) {
  1357.                datasety[i] = log10(datasety[i]);
  1358.             }
  1359.          }
  1360.          else {
  1361.             yy1 = grstat[cwin].plotclip.bottom;
  1362.             yy2 = grstat[cwin].plotclip.top;
  1363.          }
  1364.          SetWorldRect(&wr,xx1,yy1,xx2,yy2);
  1365.          SetGraphViewport(grstat[cwin].plotrect.left,
  1366.                           grstat[cwin].plotrect.top,
  1367.                           grstat[cwin].plotrect.right,
  1368.                           grstat[cwin].plotrect.bottom);
  1369.          SetWorldCoordinates(wr.left,wr.bottom,wr.right,wr.top);
  1370.  
  1371. }
  1372.  
  1373. void CopyVectors(float *x, int n, float *x1)
  1374. {
  1375.   int i;
  1376.   for (i=0; i<=n-1; i++)
  1377.   {
  1378.        x1[i] = x[i];
  1379.   }
  1380. }
  1381.  
  1382.  
  1383. void PostPlot()
  1384. {
  1385.  
  1386.          grstat[cwin].plotworld = a;
  1387.          grstat[cwin].plotclip = b;
  1388.          SetGraphViewport(grstat[cwin].drawingrect.left,
  1389.                           grstat[cwin].drawingrect.top,
  1390.                           grstat[cwin].drawingrect.right,
  1391.                           grstat[cwin].drawingrect.bottom);
  1392.          SetWorldCoordinates(grstat[cwin].plotworld.left,
  1393.                              grstat[cwin].plotworld.bottom,
  1394.                              grstat[cwin].plotworld.right,
  1395.                              grstat[cwin].plotworld.top);
  1396.  
  1397.  
  1398. }
  1399.  
  1400. void LinePlotData(float *datasetx,float *datasety,int numdat,
  1401.                   int color,int linestyle)
  1402.  
  1403. {
  1404.    int oldcolor;
  1405.    float *tx, *ty;
  1406.  
  1407.          tx = (float *) calloc(numdat,4);
  1408.          ty = (float *) calloc(numdat,4);
  1409.  
  1410.         oldcolor = getcolorXX();
  1411.         SelectColor(color);
  1412.         setlinestyleXX(linestyle, 0, 1);
  1413.  
  1414.         CopyVectors(datasetx, numdat, tx);
  1415.         CopyVectors(datasety, numdat, ty );
  1416.         PrePlot(tx,ty,numdat);
  1417.         MoveWorldAbs(tx[0],ty[0]);
  1418.         PolyLineWorldAbs(tx,ty,numdat);
  1419.         PostPlot();
  1420.  
  1421.  
  1422.         SelectColor( oldcolor );
  1423.         setlinestyleXX(0,0, 1);
  1424.         free(tx); free(ty);
  1425. }
  1426.  
  1427. void BargraphData(float *datasetx, float *datasety,
  1428.                   int numdat,float  width,int color,int HatchStyle)
  1429. {
  1430.    int i;
  1431.    float xx1;
  1432.    float yy1;
  1433.    float xx2;
  1434.    float yy2;
  1435.    float *tx, *ty;
  1436.    int oldcolor;
  1437.  
  1438.          oldcolor = getcolorXX();
  1439.          setfillstyleXX(HatchStyle,color);
  1440.  
  1441.          tx = (float *) calloc(numdat,4);
  1442.          ty = (float *) calloc(numdat,4);
  1443.          CopyVectors(datasetx, numdat, tx);
  1444.          CopyVectors(datasety, numdat, ty );
  1445.          PrePlot(tx,ty,numdat);
  1446.          MoveWorldAbs(datasetx[0],datasety[0]);
  1447.          if ( (grstat[cwin].plotclip.top >= 0.0) &&
  1448.               (grstat[cwin].plotclip.bottom >= 0.0) ) {
  1449.                 yy1 = grstat[cwin].plotclip.bottom;
  1450.          }
  1451.          if ( (grstat[cwin].plotclip.top >= 0.0) &&
  1452.               (grstat[cwin].plotclip.bottom < 0.0) ) {
  1453.                 yy1 = 0.0;
  1454.          }
  1455.          if ( (grstat[cwin].plotclip.top <= 0.0) &&
  1456.                (grstat[cwin].plotclip.bottom <= 0.0) ) {
  1457.                 yy1 = grstat[cwin].plotclip.top;
  1458.          }
  1459.          if (grstat[cwin].LogX)
  1460.               width = (log10(grstat[cwin].plotclip.right)
  1461.                        -log10(grstat[cwin].plotclip.left))/(numdat*1.10);
  1462.          if (grstat[cwin].LogY)
  1463.               yy1 = log10(yy1);
  1464.  
  1465.          for ( i = 0; i <= numdat - 1; i++ ) {
  1466.             yy2 = ty[i];
  1467.             xx1 = tx[i];
  1468.             BarWorld(xx1,yy1,(yy2 - yy1),width,color,HatchStyle);
  1469.          }
  1470.  
  1471.          PostPlot();
  1472.          SelectColor( oldcolor);
  1473.          free(tx); free(ty);
  1474.  
  1475. }
  1476.  
  1477. void PlotErrorBars(float *datasetx, float *datasety1,
  1478.                    float *datasety2,int numdat,int color,float width)
  1479. {
  1480.    int i,oldcolor;
  1481.    float xx1;
  1482.    float yy1;
  1483.    float xx2;
  1484.    float yy2;
  1485.    float *tx, *ty1, *ty2;
  1486.  
  1487.          tx = (float *) calloc(numdat,4);
  1488.          ty1 = (float *) calloc(numdat,4);
  1489.          ty2 = (float *) calloc(numdat,4);
  1490.          CopyVectors( datasetx, numdat, tx);
  1491.          CopyVectors( datasety1,numdat, ty1 );
  1492.          CopyVectors( datasety2,numdat, ty2);
  1493.          oldcolor = getcolorXX();
  1494.          SelectColor(color);
  1495.  
  1496.          PrePlot(tx,ty1,numdat);
  1497.          if (grstat[cwin].LogY  )
  1498.            for (i = 0; i <= numdat-1; i++ )
  1499.               ty2[i] = log10(ty2[i]);
  1500.   
  1501.          if (grstat[cwin].LogX)
  1502.               width = (log10(grstat[cwin].plotclip.right)
  1503.                        -log10(grstat[cwin].plotclip.left))/(numdat*1.10);
  1504.          for ( i = 0; i <= numdat - 1; i++ ) {
  1505.             yy1 = ty1[i];
  1506.             yy2 = ty2[i];
  1507.             xx1 = tx[i] - width / 2.0;
  1508.             xx2 = xx1 + width;
  1509.             MoveWorldAbs(xx1,yy1);
  1510.             LineWorldAbs(xx2,yy1);
  1511.             MoveWorldAbs(xx1,yy2);
  1512.             LineWorldAbs(xx2,yy2);
  1513.          }
  1514.          PostPlot();
  1515.          SelectColor(oldcolor);
  1516.          free(tx); free( ty1); free(ty2);
  1517. }
  1518.  
  1519. void ScatterPlotData(float *datasetx,float *datasety,
  1520.                      int numdat,int color, int marktype)
  1521. {
  1522.    float  PolyFillX[3][7];
  1523.    float  PolyFillY[3][7];
  1524.  
  1525.    int i,k,oldcolor;
  1526.    float pfx[7];
  1527.    float pfy[7];
  1528.    float pfsfx;
  1529.    float pfsfy;
  1530.    float *tx, *ty;
  1531.  
  1532.    PolyFillX[0][0] = -0.5;
  1533.    PolyFillX[0][1] =  0.0;
  1534.    PolyFillX[0][2] =  1.0;
  1535.    PolyFillX[0][3] =  0.0;
  1536.    PolyFillX[0][4] = -1.0;
  1537.    PolyFillX[0][5] =  0.0;
  1538.    PolyFillX[0][6] =  0.0;
  1539.  
  1540.    PolyFillX[1][0] = -0.5;
  1541.    PolyFillX[1][1] =  0.5;
  1542.    PolyFillX[1][2] =  0.5;
  1543.    PolyFillX[1][3] = -1.0;
  1544.    PolyFillX[1][4] =  0.0;
  1545.    PolyFillX[1][5] =  0.0;
  1546.    PolyFillX[1][6] =  0.0;
  1547.  
  1548.    PolyFillX[2][0] =  0.0;
  1549.    PolyFillX[2][1] = -0.5;
  1550.    PolyFillX[2][2] =  0.5;
  1551.    PolyFillX[2][3] =  0.5;
  1552.    PolyFillX[2][4] = -0.5;
  1553.    PolyFillX[2][5] =  0.0;
  1554.    PolyFillX[2][6] =  0.0;
  1555.  
  1556.    PolyFillY[0][0] = -0.5;
  1557.    PolyFillY[0][1] =  1.0;
  1558.    PolyFillY[0][2] =  0.0;
  1559.    PolyFillY[0][3] = -1.0;
  1560.    PolyFillY[0][4] =  0.0;
  1561.    PolyFillY[0][5] =  0.0;
  1562.    PolyFillY[0][6] =  0.0;
  1563.  
  1564.    PolyFillY[1][0] = -0.5;
  1565.    PolyFillY[1][1] =  1.0;
  1566.    PolyFillY[1][2] = -1.0;
  1567.    PolyFillY[1][3] =  0.0;
  1568.    PolyFillY[1][4] =  0.0;
  1569.    PolyFillY[1][5] =  0.0;
  1570.    PolyFillY[1][6] =  0.0;
  1571.  
  1572.    PolyFillY[2][0] = -0.5;
  1573.    PolyFillY[2][1] =  0.5;
  1574.    PolyFillY[2][2] =  0.5;
  1575.    PolyFillY[2][3] = -0.5;
  1576.    PolyFillY[2][4] = -0.5;
  1577.    PolyFillY[2][5] =  0.0;
  1578.    PolyFillY[2][6] =  0.0;
  1579.          if( marktype >2) marktype = 0;
  1580.          tx = (float *) calloc(numdat,4);
  1581.          ty = (float *) calloc(numdat,4);
  1582.          CopyVectors(datasetx, numdat, tx );
  1583.          CopyVectors(datasety, numdat, ty );
  1584.          oldcolor = getcolorXX();
  1585.          SelectColor( color );
  1586.          PrePlot(tx,ty,numdat);
  1587.          if (grstat[cwin].LogX)
  1588.                 pfsfx = (log10(grstat[cwin].plotclip.right) -
  1589.                     log10(grstat[cwin].plotclip.left)) * 0.02;
  1590.          else
  1591.                 pfsfx = (grstat[cwin].plotclip.right -
  1592.                     grstat[cwin].plotclip.left) * 0.02;
  1593.          if (grstat[cwin].LogY)
  1594.                 pfsfy = (log10(grstat[cwin].plotclip.top) -
  1595.                         log10(grstat[cwin].plotclip.bottom)) * 0.02;
  1596.          else
  1597.                 pfsfy = (grstat[cwin].plotclip.top -
  1598.                         grstat[cwin].plotclip.bottom) * 0.02;
  1599.          
  1600.          for ( i = 0; i <= 6; i++ ) {
  1601.             pfx[i] = PolyFillX[marktype][i] * pfsfx;
  1602.             pfy[i] = PolyFillY[marktype][i] * pfsfy;
  1603.          }
  1604.          k = 5;
  1605.          for ( i = 0; i <= numdat - 1; i++ ) {
  1606.             MoveWorldAbs(tx[i],ty[i]);
  1607.             PolyLineWorldRel(pfx,pfy,k);
  1608.          }
  1609.          PostPlot();
  1610.          SelectColor( oldcolor );
  1611.          free(tx); free(ty);
  1612.  
  1613. }
  1614. void GroupPlotData(float *datasetx,float *GroupData,int numdat,int numgroup,
  1615.                   int GraphType,float width,int *gc, int *gh)
  1616. {
  1617.    int i;
  1618.    int j;
  1619.    float xx1;
  1620.    float yy1;
  1621.    float xx2;
  1622.    float yy2;
  1623.    float *SumVector;
  1624.    int oldcolor;
  1625.  
  1626.    float *tx, *tg;
  1627.  
  1628.       {
  1629.          tx = (float *) calloc(numdat,4);
  1630.          tg = (float *) calloc((numdat * numgroup),4);
  1631.          SumVector = (float *) calloc((numdat),4);
  1632.          CopyVectors(datasetx, numdat, tx );
  1633.          CopyVectors(GroupData, numgroup * numdat, tg );
  1634.          oldcolor = getcolorXX();
  1635.  
  1636.          for ( i = 0; i <= numdat - 1; i++ ) {
  1637.             SumVector[i] = 0.0;
  1638.          }
  1639.          for ( i = 0; i <= numgroup - 1; i++ ) {
  1640.             PrePlot(tx,&tg[i*numdat],numdat);
  1641.          }
  1642.          switch ( GraphType ) {
  1643.             case 0:
  1644.                {
  1645.                   for ( i = 0; i <= numgroup - 1; i++ ) {
  1646.                      for ( j = 0; j <= numdat - 1; j++ ) {
  1647.                         SumVector[j] = SumVector[j] + tg[i*numdat+j];
  1648.                      }
  1649.                      LinePlotData(tx,SumVector,numdat,gc[i],gh[i]);
  1650.                   }
  1651.                }
  1652.                break;
  1653.             case 1:
  1654.                for ( j = 0; j <= numdat - 1; j++ ) {
  1655.                   xx1 = datasetx[j] - width / 2.0;
  1656.                   xx2 = xx1 + width;
  1657.                   for ( i = 0; i <= numgroup - 1; i++ ) {
  1658.                      if ( grstat[cwin].plotclip.bottom >= SumVector[j] ) {
  1659.                         yy1 = grstat[cwin].plotclip.bottom;
  1660.                      }
  1661.                      else {
  1662.                         yy1 = SumVector[j];
  1663.                      }
  1664.                      SumVector[j] = SumVector[j] + GroupData[i*numdat+j];
  1665.                      yy2 = SumVector[j];
  1666.                      BarWorld(xx1,yy1,yy2 - yy1,xx2 - xx1,gc[i],gh[i]);
  1667.                   }
  1668.                }
  1669.                break;
  1670.             case 2:
  1671.                for ( j = 0; j <= numdat - 1; j++ ) {
  1672.                   for ( i = 0; i <= numgroup - 1; i++ ) {
  1673.                      xx1 = (datasetx[j] - width / 2.0) + i * (width / numgroup);
  1674.                      xx2 = xx1 + width / numgroup;
  1675.                      if ( (grstat[cwin].plotclip.top >= 0.0) && (grstat[cwin].plotclip.bottom >= 0.0) ) {
  1676.                         yy1 = grstat[cwin].plotclip.bottom;
  1677.                      }
  1678.                      if ( (grstat[cwin].plotclip.top >= 0.0) && (grstat[cwin].plotclip.bottom < 0.0) ) {
  1679.                         yy1 = 0.0;
  1680.                      }
  1681.                      if ( (grstat[cwin].plotclip.top <= 0.0) && (grstat[cwin].plotclip.bottom <= 0.0) ) {
  1682.                         yy1 = grstat[cwin].plotclip.top;
  1683.                      }
  1684.                      yy2 = GroupData[i*numdat+j];
  1685.                      BarWorld(xx1,yy1,yy2 - yy1,(xx2 - xx1),gc[i],gh[i]);
  1686.                   }
  1687.                }
  1688.                break;
  1689.          }
  1690.          PostPlot();
  1691.          SelectColor(oldcolor);
  1692.       }
  1693.       free(tx); free(tg);
  1694.  
  1695. }
  1696.  
  1697.  
  1698.  
  1699. void PieLegend(string80 *titles,int numgroup,int *gcolors, int *ghatch)
  1700. {
  1701.  float textstart= 800.0;
  1702.  float boxsize= 40.0;
  1703.  float boxstart=  725.0;
  1704.  int i;
  1705.  struct WorldRect a;
  1706.  float ypos;
  1707.  
  1708.    SetWorldRect( &a, 0.0,0.0,1000.0,1000.0);
  1709.    SetWorldCoordinates(a.left, a.bottom, a.right, a.top);
  1710.  
  1711.   settextjustifyXX(LEFT_TEXT,BOTTOM_TEXT);
  1712.   SelectColor(15);
  1713.   MoveWorldAbs( 700, 200);
  1714.   LineWorldAbs( 700.0,800.0);
  1715.   LineWorldAbs( 995.0,800.0);
  1716.   LineWorldAbs( 995.0,200.0);
  1717.   LineWorldAbs( 700.0,200.0);
  1718.   ypos = 725;
  1719.   for (i = 0; i<= numgroup-1; i++){
  1720.     SelectColor(15);
  1721.     MoveWorldAbs(textstart, ypos);
  1722.     outtextXX(  titles[i] );
  1723.     BarWorld( boxstart ,ypos,boxsize,boxsize,gcolors[i],ghatch[i]);
  1724.     ypos = ypos-(500.0/numgroup);
  1725.   }
  1726.  
  1727. }
  1728.  
  1729.  
  1730. void PieChart( float *xdata, int numgroup, int *gcolors, int *ghatch,
  1731.                string80 *titles, int pietype, int val, int per,
  1732.                int *explodetrue, float *explodepercent )
  1733. {
  1734. int i,j, xtitle,ytitle;
  1735. float  Twopi360, radius,xc,yc,xw, yw,xcenter,ycenter,
  1736.     sum,startangle,endangle,midangle,startcenter, percent;
  1737. char  numstr[80],percentstr[80], tempstr[80];
  1738.  
  1739.  
  1740.   sum = 0;
  1741.   Twopi360 = TwoPi/360.0;
  1742.   startangle = 0.0;
  1743.   endangle = 0.0;
  1744.   percent = 0.0;
  1745.   settextjustifyXX(0,CENTER_TEXT);
  1746.   if (pietype == 1)
  1747.     startcenter = 3.0;
  1748.   else startcenter = 2.0;
  1749.   xw = abs( grstat[cwin].plotrect.right - grstat[cwin].plotrect.left);
  1750.   yw = abs( grstat[cwin].plotrect.bottom - grstat[cwin].plotrect.top);
  1751.  
  1752.   xc = abs(grstat[cwin].plotrect.left - grstat[cwin].drawingrect.left) +
  1753.         xw/startcenter;
  1754.   yc = abs(grstat[cwin].drawingrect.bottom - grstat[cwin].plotrect.bottom) +
  1755.     yw/2.0;
  1756.   if (xc > yc)
  1757.     radius = 0.17 * xw ;
  1758.   else
  1759.     radius = 0.17 * yw;
  1760.  
  1761.   for (i = 0; i <= numgroup-1; i++)
  1762.     sum = sum + xdata[i];
  1763.   for (i = 0; i<= numgroup-1; i++){
  1764.     strcpy(percentstr,"");
  1765.     strcpy(numstr, "");
  1766.     xcenter = xc;
  1767.     ycenter = yc;
  1768.     SelectColor(gcolors[i]);
  1769.     setfillstyleXX(ghatch[i],gcolors[i]);
  1770.     startangle = endangle+1.0;
  1771.     if (i == 0)  startangle = 0.0;
  1772.     endangle = (endangle + ((xdata[i]/sum) *360));
  1773.     midangle = (startangle+endangle) / 2.0;
  1774.     percent  = (xdata[i]/sum)*100.0;
  1775.  
  1776.     if (val == 1)
  1777.         ConvertNum(xdata[i],0.0,sum,sum/180.0,0,numstr);
  1778.     if (per == 1) {
  1779.         sprintf(percentstr, "%*.1f", 1,percent);
  1780.         strcat(percentstr ,"%" );
  1781.         if (val==1){
  1782.                 strcpy(tempstr, " ");
  1783.                 strcat(tempstr, percentstr);
  1784.                 strcpy(percentstr, tempstr );
  1785.         }
  1786.     }
  1787.    strcat(numstr,percentstr);
  1788.    if (startangle > 359.0) { startangle = 359.0;}
  1789.    if (endangle >= 360.0)  { endangle = 360.0;}
  1790.    if (explodetrue[i]==1){
  1791.         xcenter = xc +
  1792.         ( explodepercent[i]*radius*cos(Twopi360*midangle));
  1793.         ycenter = yc +
  1794.         ( explodepercent[i]*AspectRatio*radius*sin(Twopi360*midangle));
  1795.     }
  1796.     xtitle =Round(xcenter+
  1797.                   (radius*1.1*cos(Twopi360*midangle)));
  1798.     ytitle = Round(ycenter+
  1799.                   (radius*1.1*AspectRatio*sin(Twopi360*midangle)));
  1800.  
  1801.  
  1802.     pieXX( xcenter,ycenter,startangle,endangle,radius,AspectRatio);
  1803.     if  ((midangle > 90.0) && (midangle<= 270.0))
  1804.          settextjustifyXX(RIGHT_TEXT,CENTER_TEXT);
  1805.     if (pietype == 0) {
  1806.       ytitle = ytitle + 9.0 * ((midangle > 30) && (midangle < 150));
  1807.       outtextPie( xtitle,ytitle,titles[i]);
  1808.       outtextPie( xtitle,ytitle-9,numstr);
  1809.     } else
  1810.         outtextPie(xtitle,ytitle,numstr);
  1811.  
  1812.     settextjustifyXX(0,CENTER_TEXT);
  1813. }
  1814.  if (pietype == 1)
  1815.     PieLegend(titles,numgroup,gcolors, ghatch);
  1816. }
  1817.  
  1818.  
  1819. void  FindCMMinMax( float *cm, int rows,int columns,
  1820.                     float  *minZval,  float *maxZval)
  1821. {
  1822.   int i,j;
  1823.  
  1824.  
  1825.   *minZval =  cm[0];
  1826.   *maxZval =  cm[0];
  1827.   for ( i = 0;  i < columns; i++ )
  1828.     for ( j = 0; j < rows; j++ ){
  1829.       if ( cm[i*columns+j] < *minZval)
  1830.         *minZval = cm[i*columns+j];
  1831.       if ( cm[i*columns+j] > *maxZval)
  1832.         *maxZval = cm[i*columns+j];
  1833.   }
  1834. }
  1835.  
  1836.  
  1837. void StringLegends(string80 *sv, int *GColors, int *GHatch, int n, int barLine){
  1838.  
  1839.  struct WorldRect a;
  1840.  int i;
  1841.  float charSizeX, charSizeY,xpos,ypos;
  1842.  
  1843.    settextjustifyXX( LEFT_TEXT, CENTER_TEXT);
  1844.    charSizeX = 1000.0 /((grstat[cwin].drawingrect.right
  1845.                      - grstat[cwin].drawingrect.left) / 8);
  1846.    charSizeY = 1000.0 /(abs(grstat[cwin].drawingrect.top
  1847.                      - grstat[cwin].drawingrect.bottom) / 8);
  1848.    SetWorldRect( &a, 0.0,0.0,1000.0,1000.0);
  1849.    SetWorldCoordinates(a.left, a.bottom, a.right, a.top);
  1850.  
  1851.     xpos = charSizeX + 10.0; ypos = 950.0 - charSizeY;
  1852.     for (i = 0; i <= n-1; i++ ){
  1853.       SelectColor(GColors[i]);
  1854.       if ( barLine == 0){
  1855.         MoveWorldAbs(xpos,ypos);
  1856.         setlinestyleXX(GHatch[i],0,1);
  1857.         LineWorldRel(2*charSizeX,0);
  1858.       }
  1859.       else
  1860.         BarWorld(xpos,ypos-0.75*charSizeY,1.5*charSizeY,2*charSizeX,
  1861.              GColors[i],GHatch[i]);
  1862.       MoveWorldAbs(xpos+3*charSizeX,ypos);
  1863.       outtextXX(sv[i]);
  1864.       xpos = xpos + 5*charSizeX + strlen(sv[i])*charSizeX;
  1865.       if ((i<n-1) &&
  1866.         ((xpos + 5*charSizeX + strlen(sv[i+1])*charSizeX) > 980.0))
  1867.       {
  1868.         xpos = charSizeX + 10.0;
  1869.         ypos = ypos - 2 * charSizeY;
  1870.       }
  1871.     }
  1872.     SetWorldCoordinates(grstat[cwin].plotworld.left,
  1873.                        grstat[cwin].plotworld.bottom,
  1874.                        grstat[cwin].plotworld.right,
  1875.                        grstat[cwin].plotworld.top);
  1876.  
  1877.   settextjustifyXX( LEFT_TEXT,CENTER_TEXT);
  1878. }
  1879.  
  1880. void RealLegends(float  *rv, int *GColors, int *GHatch,
  1881.                  int  n, int barLine){
  1882.  int i;
  1883.  string80 *sv;
  1884.  string80 tempstr;
  1885.  int dec;
  1886.  float min,max;
  1887.  
  1888.   sv = (string80 *) calloc(n, sizeof(string80 ));
  1889.   FindMinMax(rv,n,&min,&max);
  1890.   for (i = 0; i <= n-1; i++ ){
  1891.      ConvertNum(rv[i],min,max,max-min,0,tempstr);
  1892.      strcpy(sv[i], tempstr);
  1893.   }
  1894.   StringLegends(sv,GColors, GHatch, n, barLine);
  1895. }
  1896.  
  1897.  
  1898. void ContourPlotLegends(float *cm,int rows,int  columns,
  1899.                       float contourInc,int *GColors, int *GHatch){
  1900.  
  1901. float contourValue, minZ, maxZ;
  1902. float *contourValues;
  1903. int i;
  1904.  
  1905.     i = 0;
  1906.     FindCMMinMax(cm,rows, columns, &minZ, &maxZ);
  1907.     contourValue = minZ + contourInc;
  1908.     do {
  1909.       contourValue +=  contourInc;
  1910.       i += 1;
  1911.     } while (contourValue <= maxZ);
  1912.  
  1913.     /*  Allocated for up to i contours   */
  1914.     contourValues = (float *) calloc( i,sizeof(float ));
  1915.     i = 0;
  1916.     contourValue = minZ + contourInc;
  1917.     do {
  1918.       contourValues[i] = contourValue;
  1919.       contourValue +=  contourInc;
  1920.       i += 1;
  1921.     } while (contourValue <= maxZ);
  1922.     RealLegends(contourValues, GColors, GHatch, i, 0);
  1923.  
  1924. }
  1925.  
  1926.  
  1927.  
  1928. int CheckForContour(float *cm, int numcolumn,
  1929.                     int j1,int i1,int j2,int i2,
  1930.                     float minX,float xSpace,
  1931.                     float minY,float ySpace,
  1932.                     float contourZ,
  1933.                     float *x, float *y)
  1934. {
  1935.  
  1936.   int FunctionResult;
  1937.   float deltaX, deltaY, deltaZ;
  1938.  
  1939.   if ( ((cm[i1*numcolumn+j1] >= contourZ) &&
  1940.         (cm[i2*numcolumn+j2] <= contourZ)) ||
  1941.       ((cm[i1*numcolumn+j1] <= contourZ) &&
  1942.        (cm[i2*numcolumn+j2] >= contourZ)))
  1943.      FunctionResult = 1;
  1944.   else FunctionResult = 0;
  1945.   if ( FunctionResult== 1 ) {
  1946.     if ( (j2-j1)==1)
  1947.       deltaX = xSpace;
  1948.     else if ( (j2-j1)==-1 )
  1949.       deltaX = -xSpace;
  1950.         else deltaX = 0.0;
  1951.     if ( (i2-i1)==1 )
  1952.       deltaY = ySpace;
  1953.       else if ( (i2-i1)==-1 )
  1954.          deltaY = -ySpace;
  1955.            else deltaY = 0.0;
  1956.     deltaZ = cm[i2*numcolumn+j2] - cm[i1*numcolumn+j1];
  1957.     *x = minX + xSpace * j1 + (contourZ-cm[i1*numcolumn+j1]) * (deltaX/deltaZ);
  1958.     *y = minY + ySpace * i1 + (contourZ-cm[i1*numcolumn+j1]) * (deltaY/deltaZ);
  1959.  
  1960.  
  1961.   }
  1962.   return( FunctionResult );
  1963. }
  1964.  
  1965.  
  1966. void  ContourPlot( float *cm,
  1967.                   int rows, int columns,
  1968.                   float contourInc,
  1969.                   int *GColors, int *GHatch)
  1970. {
  1971. int i,j,k,contourCounter,numContours;
  1972. float xpos,ypos,contourValue,minZ, maxZ;
  1973. float minX, xSpace, minY, ySpace;
  1974. float x[4],y[4];
  1975. int contourFound[4];
  1976. char gridLabel[16];
  1977. struct WorldRect wr;
  1978.  
  1979.   minX =  grstat[cwin].plotclip.left;
  1980.   xSpace = (grstat[cwin].plotclip.right- grstat[cwin].plotclip.left) /
  1981.            (columns - 1.0 ) ;
  1982.   minY =  grstat[cwin].plotclip.bottom;
  1983.   ySpace = (grstat[cwin].plotclip.top- grstat[cwin].plotclip.bottom) /
  1984.            (rows - 1.0 ) ;
  1985.   SetWorldRect(&wr,grstat[cwin].plotclip.left,grstat[cwin].plotclip.bottom,
  1986.                   grstat[cwin].plotclip.right,grstat[cwin].plotclip.top );
  1987.   SetGraphViewport(grstat[cwin].plotrect.left,grstat[cwin].plotrect.top,
  1988.                    grstat[cwin].plotrect.right, grstat[cwin].plotrect.bottom);
  1989.   SetWorldCoordinates(wr.left, wr.bottom, wr.right, wr.top);
  1990.  
  1991.   contourCounter = 0;
  1992.   FindCMMinMax(cm,rows, columns, &minZ, &maxZ);
  1993.   contourValue = minZ + contourInc;
  1994.   do {
  1995.     setlinestyleXX(GHatch[contourCounter],1,1);
  1996.     SelectColor(GColors[contourCounter]);
  1997.     for ( i = 0; i <= rows-2; i++ ){
  1998.        for ( j = 0; j <= columns-2 ; j++ ){
  1999.  
  2000. /*top*/    contourFound[0] = CheckForContour(cm,columns,j,i,j+1,i,
  2001.                                             minX, xSpace, minY, ySpace,
  2002.                                             contourValue,&x[0],&y[0]);
  2003. /*right*/  contourFound[1] = CheckForContour(cm,columns,j+1,i,j+1,i+1,
  2004.                                             minX, xSpace, minY, ySpace,
  2005.                                             contourValue, &x[1],&y[1]);
  2006. /*bottom*/ contourFound[2] = CheckForContour(cm,columns,j+1,i+1,j,i+1,
  2007.                                             minX, xSpace, minY, ySpace,
  2008.                                             contourValue, &x[2],&y[2]);
  2009. /*left*/   contourFound[3] = CheckForContour(cm,columns,j,i+1,j,i,
  2010.                                             minX, xSpace, minY, ySpace,
  2011.                                             contourValue,&x[3],&y[3]);
  2012.          numContours = 0;
  2013.          for ( k = 0; k <= 3 ; k++ ){
  2014.           if ( contourFound[k]== 1  ){
  2015.              x[numContours] = x[k];
  2016.              y[numContours] = y[k];
  2017.              numContours +=  1;
  2018.            }
  2019.          }
  2020.          switch ( numContours ){
  2021.           case  2:
  2022.                  MoveWorldAbs(x[0],y[0]);
  2023.                  LineWorldAbs(x[1],y[1]);
  2024.                 break;
  2025.           case 3:
  2026.                   MoveWorldAbs(x[0],y[0]);
  2027.                   LineWorldAbs(x[2],y[2]);
  2028.                   break;
  2029.           case 4:
  2030.                   MoveWorldAbs(x[0],y[0]);
  2031.                   LineWorldAbs(x[2],y[2]);
  2032.                   MoveWorldAbs(x[1],y[1]);
  2033.                   LineWorldAbs(x[3],y[3]);
  2034.                   break;
  2035.           default: break;
  2036.            }
  2037.       }
  2038.     }
  2039.     contourValue += contourInc;
  2040.     contourCounter += 1;
  2041.   }while (contourValue <= maxZ);
  2042.   SetGraphViewport( grstat[cwin].drawingrect.left,
  2043.                     grstat[cwin].drawingrect.top,
  2044.                     grstat[cwin].drawingrect.right,
  2045.                     grstat[cwin].drawingrect.bottom );
  2046.   SetWorldCoordinates(grstat[cwin].plotworld.left,
  2047.                       grstat[cwin].plotworld.bottom,
  2048.                       grstat[cwin].plotworld.right,
  2049.                       grstat[cwin].plotworld.top);
  2050. }
  2051.  
  2052.  
  2053. void LabelPlotArea(float x,float y,char *GrLabel,int xjust,int yjust)
  2054. {
  2055.    float xx1;
  2056.    float xx2;
  2057.    float yy1;
  2058.    float yy2;
  2059.    struct WorldRect a;
  2060.    struct WorldRect b;
  2061.  
  2062.          a = grstat[cwin].plotworld;
  2063.          b = grstat[cwin].plotclip;
  2064.          if ( grstat[cwin].LogX ) {
  2065.             xx1 = log10(grstat[cwin].plotclip.left);
  2066.             xx2 = log10(grstat[cwin].plotclip.right);
  2067.             x = log10(x);
  2068.          }
  2069.          else {
  2070.             xx1 = grstat[cwin].plotclip.left;
  2071.             xx2 = grstat[cwin].plotclip.right;
  2072.          }
  2073.          if ( grstat[cwin].LogY ) {
  2074.             yy1 = log10(grstat[cwin].plotclip.bottom);
  2075.             yy2 = log10(grstat[cwin].plotclip.top);
  2076.             y = log10(y);
  2077.          }
  2078.          else {
  2079.             yy1 = grstat[cwin].plotclip.bottom;
  2080.             yy2 = grstat[cwin].plotclip.top;
  2081.          }
  2082.          SetGraphAreaWorld(xx1,yy1,xx2,yy2);
  2083.          settextjustifyXX( xjust, yjust );
  2084.          MoveWorldAbs( x,y );
  2085.          outtextXX(GrLabel);
  2086.          grstat[cwin].plotworld = a;
  2087.          grstat[cwin].plotclip = b;
  2088.          settextjustifyXX( LEFT_TEXT, CENTER_TEXT );
  2089. }
  2090.  
  2091. void LabelGraphWindow(float x,float y,char *GrLabel,int xjust,int yjust)
  2092. {
  2093.    float x1;
  2094.    float y1;
  2095.    struct WorldRect a;
  2096.  
  2097.          SetWorldRect( &a, 0.0,0.0,1000.0,1000.0);
  2098.          SetWorldCoordinates(a.left, a.bottom, a.right, a.top);
  2099.          settextjustifyXX( xjust, yjust );
  2100.          MoveWorldAbs( x, y );
  2101.          outtextXX( GrLabel );
  2102.          SetWorldCoordinates( grstat[cwin].plotworld.left, grstat[cwin].plotworld.bottom,
  2103.                               grstat[cwin].plotworld.right, grstat[cwin].plotworld.top  );
  2104.          settextjustifyXX( LEFT_TEXT, CENTER_TEXT );
  2105.  
  2106. }
  2107.  
  2108.  
  2109. void TitleXAxis(char *XTitle)
  2110. {
  2111.    float x;
  2112.    float y;
  2113.    int font;
  2114.    int dir;
  2115.    int size;
  2116.  
  2117.          x = 500.0;
  2118.          y = 15.0;
  2119.          gettextstyleXX(&font,&dir,&size);
  2120.          settextstyleXX( font, 0,size );
  2121.          LabelGraphWindow( x,y, XTitle, 1,0);
  2122.          settextstyleXX( font, dir,size );
  2123. }
  2124.  
  2125. void TitleYAxis(char *YTitle)
  2126. {
  2127.    float x;
  2128.    float y;
  2129.    int font;
  2130.    int dir;
  2131.    int size;
  2132.  
  2133.          x = 30.0;
  2134.          y = 500.0;
  2135.          gettextstyleXX(&font,&dir,&size);
  2136.          settextstyleXX( font, 1,size );
  2137.          LabelGraphWindow( x,y, YTitle, 1, 1 );
  2138.          settextstyleXX( font, dir,size );
  2139.  
  2140. }
  2141.  
  2142. void TitleWindow(char *GTitle)
  2143. {
  2144.    float x;
  2145.    float y;
  2146.    int font;
  2147.    int dir;
  2148.    int size;
  2149.  
  2150.         x = 500.0;
  2151.         y = 980.0;
  2152.         gettextstyleXX(&font,&dir,&size);
  2153.         settextstyleXX( font, 0,size );
  2154.         LabelGraphWindow( x,y,GTitle,1,2);
  2155.         settextstyleXX( font, dir,size );
  2156. }
  2157.  
  2158.  
  2159. void InitSEGraphics(int cmode)
  2160. {
  2161.    int GMX;
  2162.    int GMY;
  2163.    int x1;
  2164.    int x2;
  2165.    int y1;
  2166.    int y2;
  2167.    int i;
  2168.  
  2169.    BlackAndWhite = 0;
  2170.    if ((cmode == 7) || (cmode == 2) || (cmode == 3) || (cmode == 12))
  2171.       BlackAndWhite = 1;
  2172.    for (i=0; i<=10; i++)
  2173.      SetWorldRect(&grstat[i].win2plotratio,0.166,0.166,0.166,0.166);
  2174.    OneTimeInit(cmode);
  2175.  
  2176.    GetMaxCoords( &GMX,&GMY);
  2177.    AspectRatio = ((GMY*1.3)/(GMX*1.0));
  2178.  
  2179.   SetPercentWindow(0.1,0.1,0.90,0.90,0);
  2180.   SetWin2PlotRatio(0,0.15,0.12,0.05,0.12);
  2181.  
  2182.   SetPercentWindow(0.1,0.1,0.90,0.90,1);
  2183.   SetWin2PlotRatio(1,0.15,0.12,0.05,0.12);
  2184.  
  2185.   SetPercentWindow(0.01,0.01,0.99,0.99,2);
  2186.   SetWin2PlotRatio(2,0.14,0.12,0.05,0.12);
  2187.  
  2188.   SetPercentWindow(0.01,0.01,0.99,0.49,3);
  2189.   SetWin2PlotRatio(3,0.15,0.14,0.05,0.17);
  2190.  
  2191.   SetPercentWindow(0.01,0.501,0.99,0.99,4);
  2192.   SetWin2PlotRatio(4,0.15,0.14,0.05,0.17);
  2193.  
  2194.   SetPercentWindow(0.01,0.01,0.49,0.99,5);
  2195.   SetWin2PlotRatio(5,0.21,0.14,0.06,0.14);
  2196.  
  2197.   SetPercentWindow(0.501,0.01,0.99,0.99,6);
  2198.   SetWin2PlotRatio(6,0.21,0.14,0.06,0.14);
  2199.  
  2200.   SetPercentWindow(0.001,0.01,0.49,0.49,7);
  2201.   SetWin2PlotRatio(7,0.21,0.19,0.05,0.19);
  2202.  
  2203.   SetPercentWindow(0.501,0.01,0.99,0.49,8);
  2204.   SetWin2PlotRatio(8,0.21,0.19,0.05,0.19);
  2205.  
  2206.   SetPercentWindow(0.01,0.501,0.49,0.99,9);
  2207.   SetWin2PlotRatio(9,0.21,0.19,0.06,0.19);
  2208.  
  2209.   SetPercentWindow(0.501,0.501,0.99,0.99,10);
  2210.   SetWin2PlotRatio(10,0.21,0.18,0.05,0.18);
  2211.  
  2212.   ScalePlotArea(0.0,0.0,100.0,100.0);
  2213. }
  2214.  
  2215.  
  2216. void CloseSEGraphics()
  2217. {
  2218.       closegraphics();
  2219. }
  2220.  
  2221.  
  2222.