home *** CD-ROM | disk | FTP | other *** search
/ Hacker Chronicles 2 / HACKER2.BIN / 149.GRAPHWAV.PAS < prev    next >
Pascal/Delphi Source File  |  1988-06-30  |  14KB  |  360 lines
  1. (****************************************************************************)
  2. (***                                                                      ***)
  3. (***  GraphResults plots either the time domain data or the frequency     ***)
  4. (***  domain data, as determined by the value of parameter PlotType. The  ***)
  5. (***  data is either plotted over the whole interval, or over a user      ***)
  6. (***  defined subinterval. Additionally, a hard copy may be made of the   ***)
  7. (***  current screen, a zoom factor may be given, or the type of plot may ***)
  8. (***  be changed. Initially the plot is drawn as a log-log plot. Four     ***)
  9. (***  types of plots are defined:                                         ***)
  10. (***       1. Linear x, linear y.                                         ***)
  11. (***       2. Log x,    log y.                                            ***)
  12. (***       3. Log x,    linear y.                                         ***)
  13. (***       4. Linear x, log y.                                            ***)
  14. (***                                                                      ***)
  15. (***                                                                      ***)
  16. (****************************************************************************)
  17.  
  18. UNIT GraphWaveform;
  19.  
  20. INTERFACE
  21. USES
  22. {$IFDEF DOSCrt}
  23.    DOSCrt,
  24. {$ELSE}
  25.    Crt,
  26. {$ENDIF}
  27.    Extended_Reals,
  28.    Graph,
  29.    DrawGraf,
  30.    Global,
  31.    TextOps,
  32.    GraphText,
  33.    Application_Specifics;
  34.  
  35. PROCEDURE GraphResults (PlotType : CHAR);
  36.  
  37. PROCEDURE Graph_Wave;
  38.  
  39. (****************************************************************************)
  40.  
  41. IMPLEMENTATION
  42.  
  43. CONST
  44.    NormSize   = 1;
  45.    LineX      = 60;
  46.    LineY      = 16;
  47.  
  48. VAR
  49.    i          : INTEGER;     (* Loop counter                             *)
  50.    MinFirst   : INTEGER;     (* Smallest index that can be graphed.      *)
  51.    MaxLast    : INTEGER;     (* Largest  index that can be graphed.      *)
  52.    first      : INTEGER;     (* Subinterval setup: graph from            *)
  53.    last       : INTEGER;     (*    first to last points of Temp.         *)
  54.    RightEnd   : REAL;        (* Subinterval setup: user                  *)
  55.    LeftEnd    : REAL;        (*      inputted endpoints.                 *)
  56.    tempx      : REAL;        (* Temp var for swapping values.            *)
  57.    temp       : REAL;        (* Variable for swapping values.            *)
  58.    Title      : string;      (* Title of graph.                          *)
  59.    XTitle     : INTEGER;     (* X coordinate to print title.             *)
  60.    YTitle     : INTEGER;     (* Y coordinate to print title.             *)
  61.    TitlePos   : INTEGER;     (* Position of 'Title:' in title.           *)
  62.    j          : BYTE;        (* Temp counter variable.                   *)
  63.    Plot       : BYTE;        (* Plot type.                               *)
  64.    PlotMAG    : boolean;     (* Magnitude of frequency data?             *)
  65.    PlotPHASE  : boolean;     (* Phase of frequency data?                 *)
  66.    X_Units    : string;
  67.    Y_Units    : string;
  68.    leftx      : INTEGER;               (* Left edge of window boundary      *)
  69.    rightx     : INTEGER;               (* Right edge of window boundary     *)
  70.    topy       : INTEGER;               (* Top edge of window boundary       *)
  71.    bottomy    : INTEGER;               (* Bottom edge of window boundary    *)
  72.  
  73. {----------------------------------------------------------------------------}
  74.  
  75. PROCEDURE ClearWindow (x_1,y_1,x_2,y_2 : INTEGER);
  76.  
  77.    VAR
  78.       v : ViewPortType;
  79.  
  80.    BEGIN   {ClearWindow}
  81.       GetViewSettings (v);
  82.       SetViewPort (x_1,y_1,x_2,y_2,ClipOff);
  83.       ClearViewPort;
  84.       WITH v DO
  85.          SetViewPort (x1,y1,x2,y2,Clip);
  86.    END;   {ClearWindow}
  87.  
  88. PROCEDURE ClearTextWindow (x_1,y_1,x_2,y_2 : INTEGER);
  89.  
  90.    BEGIN   {ClearTextWindow}
  91.       Text_To_Cart (x_1,y_1,x_1,y_1);
  92.       Text_To_Cart (x_2,y_2,x_2,y_2);
  93.       ClearWindow (x_1,y_1,x_2,y_2);
  94.    END;   {ClearTextWindow}
  95.  
  96.  
  97. PROCEDURE PrintMenu;
  98.  
  99.    VAR
  100.       x, y  : INTEGER;
  101.  
  102.    BEGIN   {PrintMenu}
  103.       Text_To_Cart (LineX,LineY,x,y);
  104.       Line (x,0,x,GetMaxY);
  105.       Line (x,y,GetMaxX,y);
  106.       ClearTextWindow (LineX+1,LineY+1,80,25);
  107.       WriteText ('Select Option:    ',LineX+2,LineY+1);
  108.       WriteText ('  1. Print Screen ',LineX+2,LineY+3);
  109.       WriteText ('  2. Plot Type    ',LineX+2,LineY+4);
  110.       WriteText ('  3. Interval     ',LineX+2,LineY+5);
  111.       WriteText ('  9. Main Menu    ',LineX+2,LineY+6);
  112.       WriteText ('Your Choice? ',LineX+2,LineY+8);
  113.    END;   {PrintMenu}
  114.  
  115. {----------------------------------------------------------------------------}
  116. {-                                                                          -}
  117. {-    GraphData graphs the data. Initially, time data is graphed on a       -}
  118. {-    linear (type 1) graph, magnitudes are graphed on log-log (type 2)     -}
  119. {-    graphs, and phase is plotted on a semi-log (type 3) graph.            -}
  120. {-                                                                          -}
  121. {----------------------------------------------------------------------------}
  122.  
  123. PROCEDURE GraphData;
  124.  
  125.    CONST
  126.       shift     : REAL = 0;     (* y offset for graphing data               *)
  127.       NumDigits        = 4;     (* number of digits of delay to display     *)
  128.  
  129.  
  130.    VAR
  131.       Delay  : REAL;            (* X offset of data to be graphed.          *)
  132.       dummy  : string [20];
  133.       error  : BYTE;            (* Error code returned by DrawGraph         *)
  134.       ErrStr : string[3];
  135.       i      : INTEGER;
  136.  
  137.    BEGIN   {GraphData}
  138.       SetViewPort (0,0,GetMaxX,GetMaxY,ClipOn);
  139.       ClearWindow (0,0,GetMaxX,GetMaxY);
  140.       FOR i:=first TO last DO BEGIN
  141.          TempXPtr^[i-first]:=OutArrayX^[i];
  142.          TempYPtr^[i-first]:=OutArrayY^[i];
  143.       END;   {FOR}
  144.       leftx:=0;
  145.       rightx:=5*((GetMaxX+1) div 8);
  146.       topy:=5*(char_height div 2);
  147.       bottomy:=GetMaxY-2*char_height;
  148.       DrawGraph (TempXPtr,TempYPtr,last-first+1,Plot,leftx,topy,
  149.                  rightx,bottomy,delay,shift,X_Units,Y_Units,error);
  150.       Value_To_String (Delay,NumDigits,dummy);
  151.       dummy:='X Delay: '+dummy+'s';
  152.       WriteText (dummy,LineX+2,LineY-2);
  153.       IF error <> 0 THEN BEGIN
  154.          GotoXY (11,13);
  155.          Write ('[Error ',error,' in drawing routine]');
  156.       END;   {IF error}
  157.       Display_Test_Point_Info;
  158.    END;   {GraphData}
  159.  
  160. {----------------------------------------------------------------------------}
  161. {-                                                                          -}
  162. {-    ChangeIntervals divides the array to be graphed into subintervals     -}
  163. {-    as input by the user.                                                 -}
  164. {-                                                                          -}
  165. {----------------------------------------------------------------------------}
  166.  
  167. PROCEDURE ChangeIntervals;
  168.  
  169.    VAR
  170.       i           : INTEGER;
  171.       EndString   : string;           (* Right endpoint + multiplier  *)
  172.       old_last    : INTEGER;          (* store old right endpoint     *)
  173.       x1,x2,y1,y2 : INTEGER;          (* Window coordinates of menu   *)
  174.  
  175.    BEGIN   {ChangeIntervals}
  176.       old_last:=last;
  177.       ClearLine (LineX+1,LineY+8,18);
  178.       WriteText ('Maximum: ',LineX+2,LineY+8);
  179.       ReadText (EndString,LineX+11,LineY+8);
  180.       IF length (EndString) > 0
  181.          THEN String_to_Value (EndString,RightEnd,EndString)
  182.          ELSE RightEnd:=OutArrayX^[MaxLast];
  183.       i:=MaxLast;
  184.       WHILE ((OutArrayX^[i] >= RightEnd) AND (i > MinFirst)) DO DEC (i,1);
  185.       last:=i;
  186.       IF (last-first) < 5 THEN BEGIN
  187.          WriteText ('Too few points! ',LineX+2,LineY+8);
  188.          Buzzer;
  189.          last:=old_last;
  190.       END   {then}
  191.       ELSE IF last <> old_last THEN BEGIN
  192.          GraphData;
  193.       END;   {ELSE IF}
  194.    END;   {ChangeIntervals}
  195.  
  196. {----------------------------------------------------------------------------}
  197. {-                                                                          -}
  198. {-    OutputScreen sets up the screen for a hard copy, then calls the       -}
  199. {-    PrintScreen routine to produce the hard copy.                         -}
  200. {-                                                                          -}
  201. {----------------------------------------------------------------------------}
  202.  
  203. PROCEDURE OutputScreen;
  204.  
  205.    VAR
  206.       Title    : string [80];
  207.       SubTitle : string [80];
  208.       x        : INTEGER;
  209.       y        : INTEGER;
  210.  
  211.    BEGIN   {OutputScreen}
  212.       Text_to_Cart (LineX+1,LineY+1,x,y);
  213.       ClearWindow (x,y,GetMaxX,GetMaxY);
  214.       WriteText ('Horiz units: ',LineX+2,LineY+2);
  215.       ReadText (X_Units,LineX+15,LineY+2);
  216.       WriteText ('Vert  units: ',LineX+2,LineY+4);
  217.       ReadText (Y_Units,LineX+15,LineY+4);
  218.       WriteText ('Title of graph: ',1,1);
  219.       ReadText (Title,17,1);
  220.       WriteText ('Sub-Title:      ',1,2);
  221.       ReadText (SubTitle,17,2);
  222.       GraphData;
  223.       XTitle:=(LineX-length(Title)) div 2 +2;
  224.       WriteText (Title,XTitle,1);
  225.       XTitle:=(LineX-length(SubTitle)) div 2 +2;
  226.       WriteText (SubTitle,XTitle,2);
  227.       IF NOT NoPrinter THEN Print_Screen;
  228.    END;   {OutputScreen}
  229.  
  230. {----------------------------------------------------------------------------}
  231. {-                                                                          -}
  232. {-    ChangePlotType changes the plot number or the interval endpoints.     -}
  233. {-    It is assumed that the window boundaries are already drawn.           -}
  234. {-                                                                          -}
  235. {----------------------------------------------------------------------------}
  236.  
  237. PROCEDURE ChangePlotType;
  238.  
  239.    VAR
  240.       ch         : CHAR;
  241.       NewPlotNum : BYTE;
  242.  
  243.    BEGIN   {ChangePlotType}
  244.       SetViewPort (0,0,GetMaxX,GetMaxY,ClipOn);
  245.       ClearTextWindow (LineX+1,LineY+1,80,25);
  246.       WriteText ('Select Plot:    ',LineX+2,LineY+1);
  247.       WriteText ('  1. Linear     ',LineX+2,LineY+3);
  248.       WriteText ('  2. Log        ',LineX+2,LineY+4);
  249.       WriteText ('  3. Log-Linear ',LineX+2,LineY+5);
  250.       WriteText ('  4. Linear-Log ',LineX+2,LineY+6);
  251.       WriteText ('Your Choice? ',LineX+2,LineY+8);
  252.       REPEAT
  253.          ch:=ReadKey;
  254.       UNTIL ch in ['1'..'4',ENTER];
  255.       IF ch <> ENTER
  256.          THEN NewPlotNum:=ord(ch)-ord('0')
  257.       ELSE IF PlotMAG
  258.          THEN NewPlotNum:=Logarithmic
  259.       ELSE IF PlotPHASE
  260.          THEN NewPlotNum:=LogLin
  261.       ELSE NewPlotNum:=Linear;
  262.       IF PlotPHASE THEN
  263.          IF NewPlotNum = Logarithmic
  264.             THEN NewPlotNum:= LogLin
  265.          ELSE IF NewPlotNum = LinLog
  266.             THEN NewPlotNum:= Linear;
  267.       IF NewPlotNum <> Plot THEN BEGIN
  268.          Plot:=NewPlotNum;
  269.          GraphData;
  270.       END;   {THEN}
  271.    END;   {ChangePlotType}
  272.  
  273. {----------------------------------------------------------------------------}
  274.  
  275. PROCEDURE GraphResults (PlotType : CHAR);
  276.  
  277.    VAR
  278.       choice : CHAR;
  279.  
  280.    BEGIN   {GraphResults}
  281.       X_Units:='';
  282.       Y_Units:='';
  283.       PlotMAG  :=(UpCase(PlotType) = 'M');
  284.       PlotPHASE:=(UpCase(PlotType) = 'P');
  285.       MinFirst:=0;
  286.       IF (PlotMAG OR PlotPHASE)
  287.          THEN BEGIN
  288.             MaxLast :=pred(NumFreqs);
  289.             FOR i:=MinFirst TO MaxLast DO BEGIN
  290.                OutArrayX^[i]:=freq^[i];
  291.                IF PlotMAG
  292.                   THEN OutArrayY^[i]:=mag^[i]
  293.                   ELSE OutArrayY^[i]:=phase^[i]*180/PI;
  294.             END;   {FOR}
  295.             IF PlotMAG
  296.                THEN Plot:=Logarithmic
  297.                ELSE Plot:=LogLin;
  298.          END   {then}
  299.          ELSE BEGIN
  300.             MaxLast :=pred(NumPoints);
  301.             FOR i:=MinFirst TO MaxLast DO BEGIN
  302.                OutArrayX^[i]:=time^[i];
  303.                OutArrayY^[i]:=ampl^[i];
  304.             END;   {FOR}
  305.             Plot:=Linear;
  306.          END;   {else}
  307.       first:=MinFirst;
  308.       last :=MaxLast;
  309.       InitGraph (GraphDriver,GraphMode,'');
  310.       SetViewPort (0,0,GetMaxX,GetMaxY,ClipOn);
  311.       IF GraphDriver <> HercMono THEN SetColor (White);
  312.       GraphData;
  313.       REPEAT
  314.          PrintMenu;
  315.          REPEAT
  316.             choice:=ReadKey;
  317.          UNTIL choice IN ['1'..'3','9'];
  318.          CASE choice OF
  319.             '1': OutputScreen;
  320.             '2': ChangePlotType;
  321.             '3': ChangeIntervals;
  322.             '9': BEGIN
  323.                     CloseGraph;
  324.                     TextColor (ForeColor);
  325.                     TextBackGround (BackColor);
  326.                     ClrScr;
  327.                     Exit;
  328.                  END;
  329.          END;   {CASE}
  330.       UNTIL FALSE;
  331.    END;   {GraphResults}
  332.  
  333. {----------------------------------------------------------------------------}
  334.  
  335. PROCEDURE Graph_Wave;
  336.  
  337.    VAR
  338.       ch : CHAR;
  339.  
  340.    BEGIN   {Graph_Wave}
  341.       IF TRANS
  342.          THEN BEGIN
  343.             GotoXY (StartColumn,23);
  344.             Write ('Time, Magnitude or Phase (T/M/P)?');
  345.             REPEAT
  346.                ch:=UpCase(ReadKey);
  347.             UNTIL (ch IN ['T','M','P',ENTER]);
  348.             IF (ch = ENTER)
  349.                THEN IF ORIG
  350.                   THEN GraphResults ('T')
  351.                   ELSE GraphResults ('M')
  352.                ELSE GraphResults (ch);
  353.          END   {THEN}
  354.          ELSE GraphResults ('T');
  355.    END;   {Graph_Wave}
  356.  
  357. (****************************************************************************)
  358.  
  359. BEGIN   {INITIALIZATION}
  360. END.   {UNIT GraphWaveform}