home *** CD-ROM | disk | FTP | other *** search
/ Computer Select (Limited Edition) / Computer Select.iso / dobbs / v17n04 / wavelet.exe / WAVEGRPH.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-17  |  17.2 KB  |  618 lines
  1. #define WAVEGRPH
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <graphics.h>
  5. #include <stdlib.h>
  6. #include <alloc.h>
  7. #include <dos.h>
  8.  
  9. typedef enum { FALSE, TRUE } tftype;
  10. typedef enum { APPROX, DETAIL, INPUT, OUTPUT } signaltype;
  11. typedef enum { DECOMP, RECON } wavetype;
  12. typedef enum { NONE, HELP1, HELP2 } helptype;
  13.  
  14. #include "wavegrph.h"
  15.  
  16. double *ViewExDA, *ViewExDD, *ViewExRA, *ViewExRD;
  17. int *ViewIndex, *ViewLevel;
  18. int mulY, divY, frameH, frameHm1, rowsremain;
  19. int maxY, csize, csizep1, csizem1, framemod;
  20. int arrow1, arrow2, arrow3, arrow4;
  21.  
  22. int GraphSetup(void)
  23. {
  24.     int driver = DETECT;
  25.     int mode = 0;
  26.     int error;
  27.  
  28.     detectgraph(&driver, &mode);
  29.     initgraph(&driver, &mode, "");
  30.     error = graphresult();
  31.     if (!error)
  32.     {
  33.         maxY = getmaxy();
  34.  
  35.          /* display-mode dependent constants for character sizing,
  36.                 bargraph size and postioning, bit-mapped font line and
  37.                 character postions, and arrow drawing */
  38.         switch(driver)
  39.             {
  40.                 case CGA:    /* CGA mono graphics 640 X 200 */
  41.                     mulY = 1;  divY = 1;  viewlines = 23;
  42.                     frameH = 66;  frameHm1 = 65;  framemod = 21;
  43.                     rowsremain = 2;
  44.                     trow0 = -1;  trow1 = 7;  trow2 = 15;  trow3 = 23;  trow4 = 31;
  45.                     trow5 = 39;  trow6 = 47;  trow7 = 55;  trow8 = 63;
  46.                     csize = 8;  csizem1 = 7;  csizep1 = 9;
  47.                     arrow1 = 1;  arrow2 = 3;  arrow3 = 4;  arrow4 = 6;
  48.                     break;
  49.                 case EGAMONO:    /* EGA graphics 640 X 350 */
  50.                     mulY = 175;  divY = 100;  viewlines = 41;
  51.                     frameH = 116;  frameHm1 = 115;  framemod = 33;
  52.                     rowsremain = 2;
  53.                     trow0 = -1;  trow1 = 13;  trow2 = 27;  trow3 = 41;  trow4 = 55;
  54.                     trow5 = 69;  trow6 = 83;  trow7 = 97;  trow8 = 111;
  55.                     csize = 14;  csizem1 = 13;  csizep1 = 15;
  56.                     arrow1 = 3;  arrow2 = 6;  arrow3 = 7;  arrow4 = 10;
  57.                     break;
  58.                 case VGA:    /* VGA mono graphics 640 X 480 */
  59.                     mulY = 24;  divY = 10;  viewlines = 58;
  60.                     frameH = 160;  frameHm1 = 159;  framemod = 43;
  61.                     rowsremain = 0;
  62.                     trow0 = -1;  trow1 = 18;  trow2 = 37;  trow3 = 56;  trow4 = 76;
  63.                     trow5 = 95;  trow6 = 115;  trow7 = 134;  trow8 = 152;
  64.                     csize = 19;  csizem1 = 18;  csizep1 = 20;
  65.                     arrow1 = 5;  arrow2 = 8;  arrow3 = 9;  arrow4 = 13;
  66.                     break;
  67.                 case HERCMONO:    /* Hercules mono graphics 720 X 348 */
  68.                     mulY = 174;  divY = 100;  viewlines = 41;
  69.                     frameH = 116;  frameHm1 = 115;  framemod = 33;
  70.                     rowsremain = 0;
  71.                     trow0 = -1;  trow1 = 13;  trow2 = 27;  trow3 = 41;  trow4 = 55;
  72.                     trow5 = 69;  trow6 = 83;  trow7 = 97;  trow8 = 111;
  73.                     csize = 14;  csizem1 = 13;  csizep1 = 15;
  74.                     arrow1 = 3;  arrow2 = 6;  arrow3 = 7;  arrow4 = 10;
  75.                     setviewport(40, 0, 679, 347, 1);
  76.                     break;
  77.             }
  78.  
  79.         settextstyle(SMALL_FONT, HORIZ_DIR, 0);
  80.         setusercharsize(7, 6, mulY, divY);
  81.     }
  82.     else
  83.         printf("\n%s\n", grapherrormsg(error));
  84.  
  85.     return error;
  86. }
  87.  
  88.  
  89. void GraphExit(void)
  90. {
  91.     closegraph();
  92. }
  93.  
  94.  
  95. int ScrollGraph(int scrollup)
  96. {
  97.     int Dtop, Stop, Sbot, i, displacement;
  98.     unsigned size;
  99.     void far *buffer;
  100.  
  101.     /* set move parameters according to direction of scroll */
  102.     if (scrollup) /* true value move the block down the screen */
  103.     {
  104.         Dtop = frameH * 2;
  105.         displacement = frameH;
  106.     }
  107.     else /* false value move the block up the screen */
  108.     {
  109.         Dtop = 0;
  110.         displacement = -frameH;
  111.     }
  112.  
  113.     Stop = frameH;
  114.     Sbot = (frameH * 2) - 1;
  115.  
  116.     /* create temporary buffer to hold displaced screen image */
  117.     size = imagesize(0, 1, 639, frameH);
  118.     buffer = farmalloc(size);
  119.     if (buffer)
  120.     {
  121.         for (i = 0; i < 2; i++)
  122.         {
  123.             getimage(0, Stop, 639, Sbot, buffer);
  124.             setfillstyle(EMPTY_FILL, BLACK);
  125.             bar(0, Stop, 639, Sbot);
  126.             setfillstyle(SOLID_FILL, WHITE);
  127.             putimage(0, Dtop, buffer, COPY_PUT);
  128.             Stop -= displacement;
  129.             Sbot -= displacement;
  130.             Dtop -= displacement;
  131.         }
  132.  
  133.         farfree(buffer);
  134.     }
  135.     else
  136.         return 0;
  137.  
  138.     return 1;
  139. }
  140.  
  141.  
  142. void DrawBarGraph(int left, int top, int right, int bot, double *data,
  143.                                                                                                     int length, int barsize)
  144. {
  145.     double range, newval, maxval;
  146.     int i, j, index, width, center, offset, Ltop, Lbot;
  147.     char str[20];
  148.  
  149.     width = right - left - 1;
  150.     center = (bot + top) / 2;
  151.     range = 0.95 * (double) ((bot - top - framemod) / 2);
  152.     if ((length * barsize) > width)
  153.         length = width / barsize;
  154.  
  155.     if (data[0] < 0) /* initial seed for largest magnitude of data set */
  156.         maxval = -data[0];
  157.     else
  158.         maxval = data[0];
  159.  
  160.     for (i = 1; i < length; i++)
  161.     {                /* determine largest magnitude of data set */
  162.         if (data[i] < 0)
  163.             newval = -data[i];
  164.         else
  165.             newval = data[i];
  166.  
  167.         if (newval > maxval)
  168.             maxval = newval;
  169.     }
  170.  
  171.     if (maxval == 0.0) /* default value if  all data points are zero */
  172.         maxval = 1.0;
  173.  
  174.     setfillstyle(EMPTY_FILL, BLACK); /* draw the frame of the bar graph */
  175.     bar(left, top, right, bot);
  176.     rectangle(left, top + csizep1, right, bot - csizep1);
  177.     line(left, center, right, center);
  178.     setfillstyle(SOLID_FILL, WHITE);
  179.  
  180.     for(i = 0, index = left + 1; i < length; i++)
  181.     {  /* draw the bars of the graph */
  182.         offset = (int) ((data[i] / maxval) * range);
  183.         if (offset > 0) /* properly format excursion in Y direction */
  184.         {
  185.             Ltop = center - offset;
  186.             Lbot = center;
  187.         }
  188.         else
  189.         {
  190.             Ltop = center;
  191.             Lbot = center - offset;
  192.         }
  193.  
  194.         for (j = 0; j < barsize; j++) /* draw bar to desired width */
  195.         {
  196.             line(index, Ltop, index, Lbot);
  197.             index++;
  198.         }
  199.     }
  200.  
  201.     sprintf(str, "% 10.4e", maxval); /* label max and min vertical range */
  202.     outtextxy(left, top - 1, str);
  203.     sprintf(str, "% 10.4e", -maxval);
  204.     outtextxy(left, bot - csize, str);
  205. }
  206.  
  207.  
  208. void DrawLevel(int left, int top, int right, int bot, double *data,
  209.                                 int length, int res, int barsize, signaltype heading)
  210. {
  211.     char lvlstr[3];
  212.  
  213.     DrawBarGraph(left, top, right, bot, data, length, barsize);
  214.     settextjustify(RIGHT_TEXT, TOP_TEXT);
  215.     switch (heading)
  216.     {
  217.         case DETAIL:
  218.             itoa(DispWaveLevels - res, lvlstr, 10);
  219.             outtextxy(right - 23, bot - csize, lvlstr);
  220.             outtextxy(right - 39, bot - csize, "DETAIL LEVEL");
  221.             setfillstyle(EMPTY_FILL, BLACK);
  222.             bar(313, top, 324, top + csizem1);
  223.             setfillstyle(SOLID_FILL, WHITE);
  224.             line(315, top, 322, top + csizem1);
  225.             if (WaveShown == DECOMP)  /* draw the proper arrow */
  226.             {
  227.                 line(322, top + csizem1, 324, top + arrow3);
  228.                 line(322, top + csizem1, 315, top + arrow4);
  229.             }
  230.             else
  231.             {
  232.                 line(315, top, 322, top + arrow1);
  233.                 line(315, top, 313, top + arrow2);
  234.             }
  235.             break;
  236.         case APPROX:
  237.             if ((DispWaveLevels - res) == 0)
  238.                 outtextxy(right - 23, bot - csize, "APPROXIMATION LEVEL 0");
  239.             else
  240.                 outtextxy(right - 23, bot - csize, "INTERMEDIATE APPROXIMATION");
  241.  
  242.             line(300, top, 300, top + csizem1);
  243.             if (WaveShown == DECOMP)  /* draw the proper arrow */
  244.             {
  245.                 line(300, top + csizem1, 305, top + arrow3);
  246.                 line(300, top + csizem1, 295, top + arrow3);
  247.             }
  248.             else
  249.             {
  250.                 line(300, top, 305, top + arrow2);
  251.                 line(300, top, 295, top + arrow2);
  252.             }
  253.             break;
  254.         case INPUT:
  255.             outtextxy(right - 23, bot - csize, "INPUT");
  256.             break;
  257.         case OUTPUT:
  258.             outtextxy(right - 23, bot - csize, "OUTPUT");
  259.             break;
  260.     }
  261.  
  262.     settextjustify(LEFT_TEXT, TOP_TEXT);
  263. }
  264.  
  265.  
  266. void DrawPanel(void)
  267. {
  268.     char str[30];
  269.  
  270.     setfillstyle(EMPTY_FILL, BLACK);
  271.     bar(328, 0, 639, frameH);
  272.     setfillstyle(SOLID_FILL, WHITE);
  273.     outtextxy(128, trow0,"WAVELET TRANSFORM DEMO");
  274.     switch (HelpToggle)
  275.     {
  276.         case HELP1:
  277.             outtextxy(328, trow0, "SIGNAL I/O - (I)NPUT READ  (O)UTPUT WRITE");
  278.             outtextxy(328, trow1, "");
  279.             outtextxy(328, trow2, "");
  280.             outtextxy(328, trow3, "TRANSFORM OPERATIONS - SET: (L)EVELS");
  281.             outtextxy(328, trow4, "(T)OGGLE DECOMP/RECON  (E)XECUTE");
  282.             outtextxy(328, trow5, "");
  283.             outtextxy(328, trow6, "F1 - HELP TOGGLE   (M)ORE HELP...");
  284.             outtextxy(328, trow7, "PGUP/PGDN - SCROLL   ESC - EXIT PROGRAM");
  285.             break;
  286.         case HELP2:
  287.             outtextxy(328, trow0, "WAVELET COEFFICIENTS - SET: (A)LPHA  (B)ETA");
  288.             outtextxy(328, trow1, "a - f: WAVELET COEFFICIENTS");
  289.             outtextxy(328, trow2, "");
  290.             outtextxy(328, trow3, "EXPANSION COEFFICIENTS - (C)OPY");
  291.             outtextxy(328, trow4, "(P)RUNE  (R)EAD  (V)IEW  (W)RITE (Z)ERO");
  292.             outtextxy(328, trow5, "");
  293.             outtextxy(328, trow6, "F1 - HELP TOGGLE   (M)ORE HELP...");
  294.             outtextxy(328, trow7, "PGUP/PGDN - SCROLL   ESC - EXIT PROGRAM");
  295.             break;
  296.         case NONE:
  297.             outtextxy(328, trow2, "LENGTH:");  outtextxy(328, trow4, "ALPHA:");
  298.             outtextxy(328, trow5, "BETA:");  outtextxy(328, trow6, "LEVELS:");
  299.             outtextxy(512, trow0, "a:");  outtextxy(512, trow1, "b:");
  300.             outtextxy(512, trow2, "c:");  outtextxy(512, trow3, "d:");
  301.             outtextxy(512, trow4, "e:");  outtextxy(512, trow5, "f:");
  302.             outtextxy(424 ,trow6, "SIGNAL MSE:");
  303.             itoa(DispLength, str, 10);  outtextxy(384, trow2, str);
  304.             gcvt(*DispAlpha, 15, str);  outtextxy(376, trow4, str);
  305.             gcvt(*DispBeta, 15, str);  outtextxy(368, trow5, str);
  306.             itoa(DispWaveLevels, str, 10);  outtextxy(384, trow6, str);
  307.             gcvt(DispWaveCoeff[0], 10, str);  outtextxy(528, trow0, str);
  308.             gcvt(DispWaveCoeff[1], 10, str);  outtextxy(528, trow1, str);
  309.             gcvt(DispWaveCoeff[2], 10, str);  outtextxy(528, trow2, str);
  310.             gcvt(DispWaveCoeff[3], 10, str);  outtextxy(528, trow3, str);
  311.             gcvt(DispWaveCoeff[4], 10, str);  outtextxy(528, trow4, str);
  312.             gcvt(DispWaveCoeff[5], 10, str);  outtextxy(528, trow5, str);
  313.             gcvt(DispMSE, 10, str);  outtextxy(504, trow6, str);
  314.             if (WaveShown == DECOMP)
  315.             {
  316.                 outtextxy(328, trow0, "DECOMPOSITION");
  317.                 outtextxy(328, trow1, "SIG. IN:");
  318.                 outtextxy(384, trow1, DispSignalname);
  319.                 outtextxy(328, trow3, "COF. OUT:");
  320.                 outtextxy(392, trow3, DispCoeffname);
  321.             }
  322.             else
  323.             {
  324.                 outtextxy(328, trow0, "RECONSTRUCTION");
  325.                 outtextxy(328, trow1, "SIG. OUT:");
  326.                 outtextxy(392, trow2, DispSignalname);
  327.                 outtextxy(328, trow3, "COF. IN:");
  328.                 outtextxy(384, trow3, DispCoeffname);
  329.             }
  330.     }
  331. }
  332.  
  333.  
  334. void DrawViewedLevels(void)
  335. {
  336.     int i, j, top, bot;
  337.  
  338.     clearviewport();
  339.     for (i = TopResShown, j = 0; i <= DispWaveLevels && j < 3; i++, j++)
  340.     {
  341.         top = frameH * j;
  342.         bot = top + frameHm1;
  343.         if (i == 0)
  344.         {
  345.             if (WaveShown == DECOMP)
  346.                 DrawLevel(0, 0, 313, bot, DispData, DispLength, 0, 1, INPUT);
  347.             else
  348.                 DrawLevel(0, 0, 313, bot, DispData, DispLength, 0, 1, OUTPUT);
  349.  
  350.             DrawPanel();
  351.         }
  352.         else if (i <= DispWaveLevels)
  353.         {
  354.             DrawLevel(0, top, 313, bot, DispExCoeff[2 * (i - 1)],
  355.                                                 (DispLength >> i), i, 1 << i, APPROX);
  356.             DrawLevel(326, top, 639, bot, DispExCoeff[(2 * (i - 1)) + 1],
  357.                                                                 (DispLength >> i), i, 1 << i, DETAIL);
  358.         }
  359.     }
  360. }
  361.  
  362.  
  363. void ScrollInLevel(int res, int maxlevels, int scrollup)
  364. {
  365.     int error, Gtop, Gbot;
  366.  
  367.     error = ScrollGraph(scrollup); /* scroll display in desired direction */
  368.     if (!error)
  369.     {     /* error is usually not enough memory for scrolling in VGA mode */
  370.         closegraph();
  371.         printf("Memory allocation failure during ScrollGraph\n");
  372.         exit(1);
  373.     }
  374.  
  375.     if (scrollup) /* TRUE value places new graph at top of the screen */
  376.     {
  377.         Gtop = 0;
  378.         Gbot = frameHm1;
  379.     }
  380.     else /* place new graph at bottom of screen if it exist */
  381.     {
  382.         Gtop = maxY - (frameHm1 + rowsremain);
  383.         Gbot = maxY - rowsremain;
  384.     }
  385.  
  386.     if (res == 0)
  387.     {
  388.         setfillstyle(EMPTY_FILL, BLACK);
  389.         bar(0, 0, 639, frameHm1);
  390.         setfillstyle(SOLID_FILL, WHITE);
  391.         if (WaveShown == DECOMP)
  392.             DrawLevel(0, 0, 313, frameHm1, DispData, DispLength, 0, 1, INPUT);
  393.         else
  394.             DrawLevel(0, 0, 313, frameHm1, DispData, DispLength, 0, 1, OUTPUT);
  395.  
  396.         DrawPanel();
  397.     }
  398.     else if (res <= maxlevels)
  399.     {
  400.         DrawLevel(0, Gtop, 313, Gbot, DispExCoeff[2 * (res - 1)],
  401.                 (DispLength >> res), res, (1 << res), APPROX);
  402.         DrawLevel(326, Gtop, 639, Gbot, DispExCoeff[(2 * (res - 1)) + 1],
  403.                 (DispLength >> res), res, (1 << res), DETAIL);
  404.     }
  405. }
  406.  
  407.  
  408. unsigned char GetGraphicInput(int left, int top, char *in_str, int length)
  409. {
  410.     unsigned char char_count;
  411.     char c[2];
  412.  
  413.     outtextxy(328, trow7, "PRESS ESC TO CANCEL ENTRY");
  414.     setfillstyle(EMPTY_FILL, BLACK); /* blank out the field */
  415.     bar(left, top + 1, left + (length * 8) - 1, top + csize);
  416.     char_count = 0;
  417.     c[1] = '\0';
  418.     do
  419.     {
  420.         line(left + (char_count * 8), top + csize, /* draw graphic cursor */
  421.                 left + (char_count * 8) + 6, top + csize);
  422.         c[0] = (char) getch();
  423.         if ((c[0] >= ' ') && (c[0] <= '~') && (char_count < length))
  424.         {
  425.             if ((c[0] >= 'a') && (c[0] <= 'z'))
  426.                 c[0] &= 0xdf;
  427.  
  428.                 /* replace current cursor position with typed character */
  429.             bar(left + char_count * 8, top + 1,
  430.                     left + char_count * 8 + 7, top + csizep1);
  431.             outtextxy(left + char_count * 8, top, c);
  432.             in_str[char_count++] = c[0];
  433.         }
  434.         else if ((c[0] == 0x08) && char_count)
  435.         {                                /* backspace - rubout last char */
  436.             bar(left + (char_count - 1) * 8, top + 1,
  437.                     left + char_count * 8 + 7, top + csizep1);
  438.             in_str[char_count--] = '\0';
  439.         }
  440.         else if (c[0] == 0x0d) /* ENTER characer - complete the entry */
  441.             in_str[char_count] = '\0';
  442.  
  443.         else if (c[0] == 0x1B) /* <ESC> character - abort entry */
  444.         {
  445.             in_str[0] = '\0';
  446.             char_count = 0;
  447.         }
  448.         else
  449.             beep();
  450.  
  451.     }
  452.     while ((c[0] != 0x0d) && (c[0] != 0x1b));
  453.  
  454.     setfillstyle(SOLID_FILL, WHITE);
  455.     return char_count;
  456. }
  457.  
  458.  
  459.  
  460. void GraphMessage(int left, int top, char *message_str)
  461. {
  462.     int length;
  463.  
  464.     length = -1;
  465.     do  /* determine length of the given string */
  466.     {
  467.         length++;
  468.     } while (message_str[length] != '\0');
  469.     setfillstyle(EMPTY_FILL, BLACK); /* blank out the field */
  470.     bar(left, top + 1, left + (length * 8) - 1, top + csize);
  471.     outtextxy(left, top, message_str);
  472.     setfillstyle(SOLID_FILL, WHITE);
  473. }
  474.  
  475.  
  476. void InitViewData(double *InData, double *OutData,
  477.                                                     double **ExCoeffD, double **ExCoeffR)
  478. {
  479.     int datascale, siglen;
  480.     int i, j, k;
  481.  
  482.         /* initialize storage for viewed data */
  483.     datascale = 0x0001 << DispWaveLevels;
  484.     ViewLength = ((datascale - 1) * DispLength) / datascale
  485.                                                                                 + 5 * DispWaveLevels;
  486.     ViewExDA = (double *) calloc(DispLength + ViewLength, sizeof(double));
  487.     ViewExDD = (double *) calloc(ViewLength, sizeof(double));
  488.     ViewExRA = (double *) calloc(DispLength + ViewLength, sizeof(double));
  489.     ViewExRD = (double *) calloc(ViewLength, sizeof(double));
  490.     ViewIndex = (int *) calloc(DispLength + ViewLength, sizeof(int));
  491.     ViewLevel = (int *) calloc(DispLength + ViewLength, sizeof(int));
  492.     ViewLength += DispLength;
  493.  
  494.     /* align start of detail arrays with start of approximation data */
  495.     ViewExDD -= DispLength;
  496.     ViewExRD -= DispLength;
  497.  
  498.     k = 0;
  499.  
  500.     for (i = 0; i < DispLength; i++) /* copy in the input and output data */
  501.     {
  502.         ViewExDA[k] = InData[i];
  503.         ViewExRA[k] = OutData[i];
  504.         ViewIndex[k] = i;
  505.         ViewLevel[k++] = -1;
  506.     }
  507.  
  508.     siglen = DispLength;
  509.     for (i = 0; i < DispWaveLevels; i++) /* copy in expansion coefficients */
  510.     {
  511.         siglen /= 2;
  512.         for (j = 0; j < siglen + 5; j++)
  513.         {
  514.             ViewExDA[k] = ExCoeffD[2 * i][j];
  515.             ViewExRA[k] = ExCoeffR[2 * i][j];
  516.             ViewExDD[k] = ExCoeffD[(2 * i) + 1][j];
  517.             ViewExRD[k] = ExCoeffR[(2 * i) + 1][j];
  518.             ViewIndex[k] = j;
  519.             ViewLevel[k++] = DispWaveLevels - i - 1;
  520.         }
  521.     }
  522.  
  523.         /* position starting pointer to highest level
  524.              currently shown on the display */
  525.     if (TopResShown == 0)
  526.         ViewStart = 0;
  527.     else
  528.     {
  529.         datascale = 0x0001 << (TopResShown - 1);
  530.         ViewStart = DispLength + ((datascale - 1) * DispLength) / datascale
  531.                                                                                                 + 5 * (TopResShown - 1);
  532.     }
  533.  
  534.     settextstyle(DEFAULT_FONT, HORIZ_DIR, 1);
  535.     ViewingData = TRUE;
  536. }
  537.  
  538.  
  539. void ExitViewData(void)
  540. {
  541.     ViewExRD += DispLength; /* restore original pointer locations ... */
  542.     ViewExDD += DispLength; /* to advoid null pointer assignment error */
  543.     free(ViewLevel);        /* free the data display arrays */
  544.     free(ViewIndex);
  545.     free(ViewExRD);
  546.     free(ViewExRA);
  547.     free(ViewExDD);
  548.     free(ViewExDA);
  549.     settextstyle(SMALL_FONT, HORIZ_DIR, 0); /* return character format */
  550.     setusercharsize(7, 6, mulY, divY);      /* to the default settings */
  551.     ViewingData = FALSE;
  552. }
  553.  
  554.  
  555. void ShowViewData(int offset)
  556. {
  557.     int i, j;
  558.     char str[20];
  559.  
  560.     clearviewport();
  561.     ViewStart += offset;
  562.  
  563.     if (ViewStart < 0) /* align to start of data if necessary */
  564.         ViewStart = 0;
  565.     else if (ViewStart >= ViewLength)
  566.         ViewStart = ViewLength - 1;
  567.  
  568.     if (ViewStart < DispLength) /* headings depend upon position in data */
  569.     {
  570.         outtextxy(0, 0, "LVL/ELEMT       INPUT");
  571.         outtextxy(376, 0, "   OUTPUT");
  572.     }
  573.     else
  574.     {
  575.         outtextxy(0, 0, "LVL/ELEMT   DECOMP. APPROX.   DECOMP. DETAIL");
  576.         outtextxy(376, 0, "RECON. APPROX.   RECON. DETAIL");
  577.     }
  578.  
  579.     outtextxy(0, maxY - 7, "Esc - EXIT   PGUP/PGDN - PAGE UP/DOWN");
  580.     outtextxy(320, maxY - 7, "UP/DOWN ARROW - SCROLL UP/DOWN ONE LINE");
  581.  
  582.     for(i = 0, j = 1; i < viewlines; i++, j++)
  583.     {
  584.         if ((ViewStart + i) < ViewLength)
  585.         {
  586.             if (ViewLevel[ViewStart + i] != -1)
  587.             {                     /* show levels only for wavelet transform coefficients */
  588.                 itoa(ViewLevel[ViewStart + i], str, 10);
  589.                 outtextxy(8, 8 * j, str);
  590.             }
  591.  
  592.                 /* display input and output arrays and approximation coefficients */
  593.             itoa(ViewIndex[ViewStart + i], str, 10);
  594.             outtextxy(40, 8 * j, str);
  595.             gcvt(ViewExDA[ViewStart + i], 10, str);
  596.             outtextxy(96, 8 * j, str);
  597.             gcvt(ViewExRA[ViewStart + i], 10, str);
  598.             outtextxy(376, 8 * j, str);
  599.  
  600.             if ((ViewStart + i) >= DispLength)
  601.             {        /* print detail coefficients of wavelet transform coefficients */
  602.                 gcvt(ViewExDD[ViewStart + i], 10, str);
  603.                 outtextxy(240, 8 * j, str);
  604.                 gcvt(ViewExRD[ViewStart + i], 10, str);
  605.                 outtextxy(512, 8 * j, str);
  606.             }
  607.         }
  608.     }
  609. }
  610.  
  611.  
  612. void beep(void)
  613. {
  614.     sound(500);
  615.     delay(50);
  616.     nosound();
  617. }
  618.