home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume14 / vplot / part13 < prev    next >
Text File  |  1988-03-31  |  56KB  |  1,907 lines
  1. Subject:  v14i018:  Device-independant graphics system, with drivers
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Joe Dellinger <joe@hanauma.STANFORD.EDU>
  7. Posting-number: Volume 14, Issue 18
  8. Archive-name: vplot/part13
  9.  
  10. #! /bin/sh
  11. # This is a shell archive.  Remove anything before this line, then unpack
  12. # it by saving it into a file and typing "sh file".  To overwrite existing
  13. # files, type "sh file -c".  You can also feed this as standard input via
  14. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  15. # will see the following message at the end:
  16. #        "End of archive 13 (of 24)."
  17. # Wrapped by rsalz@fig.bbn.com on Fri Mar 25 11:47:20 1988
  18. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  19. if test -f 'Imagen_device/imaglib/imagopen.c' -a "${1}" != "-c" ; then 
  20.   echo shar: Will not clobber existing file \"'Imagen_device/imaglib/imagopen.c'\"
  21. else
  22. echo shar: Extracting \"'Imagen_device/imaglib/imagopen.c'\" \(5164 characters\)
  23. sed "s/^X//" >'Imagen_device/imaglib/imagopen.c' <<'END_OF_FILE'
  24. X/*
  25. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  26. X * University. Official permission to use this software is included in
  27. X * the documentation. It authorizes you to use this file for any
  28. X * non-commercial purpose, provided that this copyright notice is not
  29. X * removed and that any modifications made to this file are commented
  30. X * and dated in the style of my example below.
  31. X */
  32. X
  33. X/*
  34. X *
  35. X *  source file:   ./filters/imaglib/imagopen.c
  36. X *
  37. X * Joe Dellinger (SEP), June 11 1987
  38. X *    Inserted this sample edit history entry.
  39. X *    Please log any further modifications made to this file:
  40. X * Stew Levin (SEP), July 2, 1987
  41. X *    Added ncopies= command line option.
  42. X */
  43. X
  44. X/*
  45. X * get Imagen specific parameters and go
  46. X */
  47. X#include <stdio.h>
  48. X#include "../include/err.h"
  49. X#include "../include/enum.h"
  50. X#include "../include/extern.h"
  51. X#include "../include/params.h"
  52. X
  53. X#define BRUTE_DEFAULT YES
  54. X
  55. X#ifdef SEP
  56. X#define GETPAR fetch
  57. X#else
  58. X#define GETPAR getpar
  59. X#endif
  60. X
  61. int             file_created = NO;
  62. int             stripped = NO;
  63. int             tex = NO;
  64. int             brute_force = BRUTE_DEFAULT;
  65. int             ncopies_document = 1;
  66. char            label[100];
  67. char            string[80];
  68. X
  69. char            mapfile[100] = "default";
  70. char            holdreason[100];
  71. char            scratch_file[100];
  72. X
  73. X/*
  74. X * The option "strip=y" was created for use with TEX, allowing plots
  75. X * to be included with text. The output is not indented, does not have
  76. X * any job control information at the start, has no erases, no "end of
  77. X * form" marker at the end, and does not attempt to put in a label.
  78. X * The option "tex=y" does everything that strip does but also rotates
  79. X * the coordinates (as appropriate for dviimp), and saves and restores
  80. X * all settings. "hold=reason" to insert document control to tell the
  81. X * imagen not to print the job until a "release jobs" (rj) is issued
  82. X * at the imagen control console.  This makes it easier to insert
  83. X * special paper for example.
  84. X */
  85. X
  86. imagopen ()
  87. X{
  88. char            name[50];
  89. char            date[50];
  90. X
  91. X/*
  92. X * physical device parameters
  93. X */
  94. X    dev_xmin = 45;
  95. X    dev_ymin = 90;
  96. X    pixels_per_inch = 300.;
  97. X    aspect_ratio = 1.0;
  98. X
  99. X/*
  100. X * device capabilities
  101. X */
  102. X    need_end_erase = YES;
  103. X    buffer_output = YES;
  104. X    smart_clip = NO;
  105. X    num_col = 0;
  106. X    mono = 1;
  107. X    dither = 3;
  108. X    pixc = 0.6;
  109. X    greyc = -0.5;
  110. X
  111. X/* Since this is a hard copy device, might as well use a nice font */
  112. X    txfont = DEFAULT_HARDCOPY_FONT;
  113. X    txprec = DEFAULT_HARDCOPY_PREC;
  114. X
  115. X    if (!GETPAR ("label", "s", label))
  116. X    {
  117. X    getname (name);
  118. X    getdate (date);
  119. X    sprintf (label, "%s, %s", name, date);
  120. X    }
  121. X    else
  122. X    {
  123. X    if ((strcmp (label, "no") == 0) || (strcmp (label, "n") == 0)
  124. X        || (strcmp (label, " ") == 0) || (strcmp (label, "") == 0))
  125. X        label[0] = '\0';
  126. X    }
  127. X
  128. X    if (isatty (fileno (pltout)))
  129. X    {
  130. X    file_created = YES;
  131. X    sprintf (scratch_file, "%s%s", IPEN_SPOOL, "/Impress_XXXXXX");
  132. X    mktemp (scratch_file);
  133. X    pltout = fopen (scratch_file, "w");
  134. X    if (pltout == NULL)
  135. X    {
  136. X        ERR (FATAL, name, "could not open scratch file %s!",
  137. X         scratch_file);
  138. X    }
  139. X    }
  140. X
  141. X    if (GETPAR ("paper", "s", string))
  142. X    {
  143. X    if (strcmp (string, "legal") == 0)
  144. X    {
  145. X        dev_xmax = 4032 - 20;
  146. X        dev_ymax = 2416 - 1;
  147. X    }
  148. X    else
  149. X    if (strcmp (string, "letter") == 0)
  150. X    {
  151. X        dev_xmax = 3296 - 20;
  152. X        dev_ymax = 2416 - 1;
  153. X    }
  154. X    else
  155. X    {
  156. X        ERR (FATAL, name, "don't recognize paper type %s!", string);
  157. X    }
  158. X    }
  159. X    else
  160. X    {
  161. X    /* letter */
  162. X    dev_xmax = 3296 - 20;
  163. X    dev_ymax = 2416 - 1;
  164. X    }
  165. X
  166. X    if (GETPAR ("tex", "s", string))
  167. X    {
  168. X    if ((string[0] == 'y') || (string[0] == 'Y'))
  169. X        stripped = YES;
  170. X    }
  171. X    else
  172. X    if (GETPAR ("strip", "s", string))
  173. X    {
  174. X    if ((string[0] == 'y') || (string[0] == 'Y'))
  175. X        stripped = YES;
  176. X    }
  177. X
  178. X    if (stripped == YES)
  179. X    {
  180. X    /* Don't leave space at edge of plot */
  181. X    dev_xmax -= dev_xmin;
  182. X    dev_xmin = 0;
  183. X/*
  184. X * Make plotting surface big enough that no matter which way they
  185. X * may use the plot, nothing will be clipped. The imagen is SUPPOSED
  186. X * to be able to handle stuff going off the page anyway.
  187. X */
  188. X    dev_ymax = dev_xmax;
  189. X    dev_ymin = dev_xmin;
  190. X
  191. X    /* TEX shifts plot 1 inch to the right; undo this */
  192. X    dev_xmax -= 300;
  193. X    dev_xmin -= 300;
  194. X
  195. X    /* Turn off label */
  196. X    label[0] = '\0';
  197. X    }
  198. X    else
  199. X    {
  200. X    if (GETPAR ("brute", "s", string))
  201. X    {
  202. X        if ((string[0] == 'n') || (string[0] == 'N'))
  203. X        brute_force = NO;
  204. X        else
  205. X        brute_force = YES;
  206. X    }
  207. X    }
  208. X
  209. X    if (!GETPAR ("hold", "s", holdreason))
  210. X    {
  211. X    holdreason[0] = '\0';
  212. X    }
  213. X
  214. X    if (!GETPAR ("ncopies copies", "i", &ncopies_document))
  215. X    {
  216. X    ncopies_document = 1;
  217. X    }
  218. X
  219. X    epause = 0;
  220. X    endpause = NO;
  221. X    size = ABSOLUTE;
  222. X}
  223. X
  224. X
  225. X/*
  226. X * get the login name of the person running the program.
  227. X */
  228. getname (name)
  229. X    char           *name;
  230. X{
  231. char            line[100];
  232. int             i;
  233. X    getpw (getuid (), line);
  234. X    i = 0;
  235. X    while ((name[i] = line[i]) != ':')
  236. X    i++;
  237. X    name[i] = '\0';
  238. X}
  239. X
  240. X/*
  241. X * get the date
  242. X */
  243. X#include <sys/time.h>
  244. getdate (date)
  245. X    char           *date;
  246. X{
  247. long            time ();
  248. long            clock;
  249. struct tm      *localtime ();
  250. char           *asctime ();
  251. X
  252. X    clock = time (0);
  253. X    sprintf (date, "%.16s", asctime (localtime (&clock)));
  254. X}
  255. END_OF_FILE
  256. if test 5164 -ne `wc -c <'Imagen_device/imaglib/imagopen.c'`; then
  257.     echo shar: \"'Imagen_device/imaglib/imagopen.c'\" unpacked with wrong size!
  258. fi
  259. # end of 'Imagen_device/imaglib/imagopen.c'
  260. fi
  261. if test -f 'Imagen_device/imaglib/ipen.mn' -a "${1}" != "-c" ; then 
  262.   echo shar: Will not clobber existing file \"'Imagen_device/imaglib/ipen.mn'\"
  263. else
  264. echo shar: Extracting \"'Imagen_device/imaglib/ipen.mn'\" \(5710 characters\)
  265. sed "s/^X//" >'Imagen_device/imaglib/ipen.mn' <<'END_OF_FILE'
  266. X.TH Ipen 9 "April 6 1986"
  267. X.SH NAME
  268. ipen \- VPLOT filter for Imagen
  269. X.PP
  270. X.SH SYNOPSIS
  271. ipen  plot_file1 [plot_file2 ...] [options]
  272. X.PP
  273. Seplib version: Ipen < Plot1.h [Plot2.h ...] [options]
  274. X.PP
  275. X.SH DESCRIPTION
  276. All
  277. X.B pen
  278. filters accept input in the
  279. X.B vplot
  280. graphical metalanguage, and either cause a
  281. plot to appear on a device or write a file which if sent to that device will
  282. create a plot.
  283. X.B Ipen
  284. is the filter for the Imagen 8/300 laser printer.
  285. It translates from vplot
  286. to the imPRESS language understood by the printer.
  287. If called without
  288. redirected output, it creates a temporary file with a unique name,
  289. spools the plot,
  290. and removes the temporary file upon exiting.
  291. The location and name of the temporary file are set when ipen
  292. is compiled, by editing an include file.
  293. If the output is redirected,
  294. the imPRESS output is written to standard out (or to out= for Seplib)
  295. and no spooling is done.
  296. X.PP
  297. X.SH OPTIONS
  298. X.PP
  299. Only Imagen-specific options are covered here.  For a list of all generic
  300. pen options, which also apply to ipen, do ``man 9 pen''.
  301. X.PP
  302. X.TP 
  303. X.B paper=letter
  304. Paper size.  Paper=legal is also possible.
  305. X.PP
  306. X.TP
  307. X.B label=string
  308. By default, plots are labeled with the username of the person making the plot
  309. and the time and date.  This can be replaced with some other label by using
  310. this option.  The label may obscure part of the plot, as it whites out
  311. a rectangle in the area it will occupy before writing text over it.
  312. X.B label=``''
  313. or
  314. X.B label=no
  315. turns off the label and the white-out rectangle.
  316. X.PP
  317. X.TP
  318. X.B strip=no tex=no
  319. If strip=y, then the output imPRESS file has no label or document control
  320. language prepended, and additional imPRESS commands to save and restore
  321. the Imagen state are prepended and appended to the file.
  322. This makes the output imPRESS
  323. file useful for inclusion into a paper via the `plot' macro of TeX.
  324. This allows your figures and text to come out of the machine together, and
  325. eliminates cutting and pasting.
  326. X(TeX is a typesetting language similar to, but newer than, troff.  Troff
  327. can also be used in a similar manner, but nobody has bothered to figure out
  328. how).
  329. X.PP
  330. X.TP
  331. X.B brute=y
  332. The Imagen is quite buggy, and complicated plots will give it a nervous
  333. breakdown, which results in it chopping up your plot into little pieces
  334. and scattering them through the next person's Imagen output.  Imagen seems
  335. incapable of fixing this very serious bug.
  336. The current version of the Imagen operating system has a special document
  337. control language option which turns on a brute-force rasterization technique,
  338. which seems to avoid this bug.  The
  339. X.B brute=y
  340. option of ipen turns this on,
  341. which also has the effect of slightly slowing down the printing of the plot.
  342. It's worth it, though!
  343. X.PP
  344. X.TP
  345. X.B hold=message
  346. This parameter tells the Imagen to print the message on the Imagen control
  347. console and wait for the ``rj'' (Release Job) command to be issued at the
  348. console.   Typical usage is hold=``insert transparency''.
  349. X.PP
  350. X.TP
  351. X.B ncopies=1
  352. This parameter is used to save time and effort by printing multiple
  353. copies of the plot on the Imagen.
  354. X.PP
  355. X.TP
  356. X.B dither=3
  357. Dithering is a means of representing a continuous-tone grey image on a
  358. hardcopy device such as the Imagen.  The default dithering method is the
  359. minimized average error algorithm.  See the Vplotraster manual page
  360. for a complete discussion of dithering options.
  361. X.PP
  362. X.TP
  363. X.B greyc=-0.5
  364. This parameter applies only when using dithering as described above.
  365. Greyc is discussed in the Pen manual page and more thoroughly
  366. in the Vplotraster manual page.  To repeat some of the discussion found
  367. elsewhere, grey scale reproduction on a hardcopy device is quite different
  368. from that on a display device.  The transition from black to white occurs
  369. more abruptly on a display device, leaving both ends of the grey scale
  370. clipped at black or white.  This nonlinearity in the perceived grey scale
  371. is a useful feature that can be simulated on the Imagen using the greyc
  372. parameter.  Greyc=-0.5 seems to give grey scale reproduction on the Imagen
  373. comparable to many graphics displays, though further experimentation might
  374. be required to bring the Imagen output into agreement with a particular
  375. device.  greyc=1. disables this correction.
  376. See the
  377. X.B vplotraster
  378. manual page for more details.
  379. X.PP
  380. X.TP
  381. X.B pixc=0.6
  382. Pixc also applies only when using dithering as described above. 
  383. Grey rasters seem significantly darker when plotted on the Imagen than
  384. when displayed on a graphics screen.  Assuming that this darkening is
  385. caused by the overlapping of dots on the Imagen, this parameter compensates
  386. for that overlap by shifting the grey color scale toward white. 
  387. Pixc=0.6 seems to give greyscale reproduction on the Imagen that is
  388. comparable to many graphics displays.
  389. pixc=1. disables this correction.
  390. See the Vplotraster manual page for more details.
  391. X.SH SEE ALSO
  392. vppen, pen, vplot, vplotraster
  393. X.PP
  394. X.SH COPYRIGHT
  395. The Vplot source is copyrighted. Please read the copyright which can be
  396. found in the accompanying Vplot manual page.
  397. X.PP
  398. X.SH AUTHOR
  399. The device-dependent code of Ipen was written by Joe Dellinger, although
  400. persons unknown seem to have also made some minor changes to it.
  401. Stew Levin has fixed some bugs and added some options.
  402. Doug Wilson wrote most of imagpoly.c.
  403. X.PP
  404. X.SH BUGS
  405. The code for ipen is quite complicated, but much of the complexity
  406. is to work around various Imagen hardware bugs in software.
  407. You should try to draw raster blocks as the first things on the imagen,
  408. as the imagen may erase a little beyond the background of the
  409. raster block if the overlay mode is ``no''. There's no easy way to
  410. correct for this imagen limitation in software.
  411. In order to use the brute=y option you have to pay for extra memory
  412. on the Imagen.
  413. END_OF_FILE
  414. if test 5710 -ne `wc -c <'Imagen_device/imaglib/ipen.mn'`; then
  415.     echo shar: \"'Imagen_device/imaglib/ipen.mn'\" unpacked with wrong size!
  416. fi
  417. # end of 'Imagen_device/imaglib/ipen.mn'
  418. fi
  419. if test -f 'Vplot_Kernel/filters/Tests/libvplot_example.c' -a "${1}" != "-c" ; then 
  420.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/Tests/libvplot_example.c'\"
  421. else
  422. echo shar: Extracting \"'Vplot_Kernel/filters/Tests/libvplot_example.c'\" \(5043 characters\)
  423. sed "s/^X//" >'Vplot_Kernel/filters/Tests/libvplot_example.c' <<'END_OF_FILE'
  424. X/*
  425. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  426. X * University. Official permission to use this software is included in
  427. X * the documentation. It authorizes you to use this file for any
  428. X * non-commercial purpose, provided that this copyright notice is not
  429. X * removed and that any modifications made to this file are commented
  430. X * and dated in the style of my example below.
  431. X */
  432. X
  433. X/*
  434. X *
  435. X *  source file:   ./filters/Tests/libvplot_example.c
  436. X *
  437. X * Joe Dellinger (SEP), June 11 1987
  438. X *    Inserted this sample edit history entry.
  439. X *    Please log any further modifications made to this file:
  440. X */
  441. X
  442. X#include    <math.h>
  443. X#include    <vplot.h>
  444. X#include    <stdio.h>
  445. X
  446. X/*
  447. X * Sample program to demonstrate simple libvplot usage.
  448. X *      Excerpted from 'legend.c', by C. R. Karish:
  449. X *      format entries for a legend for a geologic map.
  450. X *  To compile:
  451. X *      cc -o example vplot_example.c -lvplot -lm
  452. X *  To run:
  453. X *      example < infile > outfile
  454. X *      tube outfile
  455. X *  Sample input:       (remove asterisks)
  456. X *      unit "Qa"  "Quaternary alluvium"
  457. X *      unit "Tb"  "Tertiary basalt"
  458. X *      unit "Kg"  "biotite monzogranite"
  459. X *      unit "Krp"  "rhyolite porphyry"
  460. X *      unit "Krd"  "biotite rhyodacite"
  461. X */
  462. X
  463. X/*
  464. X * external parameters, used by many subroutines
  465. X */
  466. float           boxsz[2];    /* size of the symbol box, in inches */
  467. float           tab[2];    /* locations of tab stops, in inches */
  468. int             charsz;    /* text size used for explanations (in vplot size
  469. X             * units) */
  470. float           vspace;    /* vertical spacing for rock unit entries */
  471. float           vpos;    /* present location on the page (inches) */
  472. X
  473. main ()
  474. X{
  475. char            command[30], line[125], symbol[30], text[90];
  476. int             count;
  477. X
  478. X    /*
  479. X     * set global geometric parameters 
  480. X     */
  481. X
  482. X    vpos = 10.3;        /* start at 10.3 inches from bottom of page */
  483. X    vspace = 0.90;        /* base line spacing = 0.90 inches */
  484. X    charsz = 10;        /* default text size = .30 inches */
  485. X    boxsz[0] = 1.0;        /* default box: 1.0 x 0.70 inches */
  486. X    boxsz[1] = 0.70;
  487. X    tab[0] = 1.0;        /* default tabs: 1.0 and 3.5 inches */
  488. X    tab[1] = 3.5;
  489. X
  490. X    /*
  491. X     * set up a vplot output stream and coordinate system 
  492. X     */
  493. X    vp_filep (stdout);        /* initialize pc structure and open stream */
  494. X    vp_style (STANDARD);    /* origin at lower left; y axis vertical */
  495. X    vp_clip (0., 0., 8.5, 11.0);/* set clipping window */
  496. X    /* (wider than screen!) */
  497. X    vp_tfont (1, STROKE, 0);    /* use Roman simplex, full precision, */
  498. X    /* no special overlay processing */
  499. X    vp_fat ((int) (charsz / 2));/* set line width, scaled to text size */
  500. X    vp_orig (0., 0.);        /* set the user origin to coincide with */
  501. X    /* the device origin (same as default) */
  502. X
  503. X    /*
  504. X     * main loop: read and interpret input file 
  505. X     */
  506. X    while (gets (line) != NULL)
  507. X    {
  508. X    if (sscanf (line, "%s", command) == 0)    /* skip blank lines */
  509. X        continue;
  510. X    if (command[0] == '#')    /* ... and comments */
  511. X        continue;
  512. X    if ((count = sscanf (line,    /* parse strings from input */
  513. X               "%*s \"%[^\"]\" \"%[^\"]\"", symbol, text)) != 2)
  514. X    {
  515. X        fprintf (stderr, "unit count = %d\n", count);
  516. X        fprintf (stderr, "%s\n", line);    /* complain if argument */
  517. X        continue;        /* count is wrong */
  518. X    }
  519. X    mapunit (symbol, text);    /* produce some output */
  520. X    }                /* end of main loop */
  521. X    vp_endplot ();        /* close output stream */
  522. X}
  523. X
  524. mapunit (symbol, text)    /* produce an entry for a map legend */
  525. X    char           *symbol, *text;
  526. X{
  527. X    if (vpos < 1.0)        /* leave 1" bottom margin */
  528. X    feedpage ();
  529. X    vpos -= vspace / 2;        /* space down a half line */
  530. X    if (strcmp (symbol, "nobox"))    /* strcmp==TRUE means `no match' */
  531. X    {
  532. X    drawbox (tab[0], vpos);    /* draw the box */
  533. X    vp_tjust (TH_CENTER, TV_HALF);    /* center the symbol in the box */
  534. X    vp_fat ((int) ((charsz - 1) / 2));    /* pick a good text fatness */
  535. X    vp_text (tab[0] + (boxsz[0] / 2),
  536. X         vpos, charsz - 1, 0, symbol);    /* write the map symbol */
  537. X    }
  538. X    vp_fat ((int) (charsz / 2));
  539. X    vp_tjust (TH_LEFT, TV_HALF);/* reset left justification */
  540. X    vp_text (tab[1], vpos, charsz, 0, text);    /* write the explanation */
  541. X    vpos -= vspace / 2;        /* space down a half line */
  542. X}
  543. X
  544. X
  545. X/*
  546. X * draw a box, boxsz[0] by boxsz[1] inches, left edge at xpos,
  547. X *      centered vertically at ypos:
  548. X */
  549. X
  550. drawbox (xpos, ypos)
  551. X    float           xpos, ypos;
  552. X{
  553. X    vp_fat ((int) (charsz / 2));/* set linewidth, same as for text */
  554. X    vp_move (xpos, ypos - (boxsz[1] / 2));    /* move to the upper left
  555. X                         * corner */
  556. X    vp_draw (xpos + boxsz[0], ypos - (boxsz[1] / 2));    /* draw it. */
  557. X    vp_draw (xpos + boxsz[0], ypos + (boxsz[1] / 2));
  558. X    vp_draw (xpos, ypos + (boxsz[1] / 2));
  559. X    vp_draw (xpos, ypos - (boxsz[1] / 2));
  560. X}
  561. X
  562. feedpage ()
  563. X{
  564. X    vp_erase ();        /* feed a page, and reset defaults */
  565. X    vp_clip (0., 0., 8.0, 11.0);/* reset our clipping window */
  566. X    vp_tfont (1, STROKE, 0);    /* reset our font */
  567. X    vp_fat ((int) (charsz / 2));/* reset our fatness */
  568. X    vp_orig (0., 0.);        /* reset our origin */
  569. X    vpos = 10.3;        /* start at the top of the page */
  570. X}
  571. END_OF_FILE
  572. if test 5043 -ne `wc -c <'Vplot_Kernel/filters/Tests/libvplot_example.c'`; then
  573.     echo shar: \"'Vplot_Kernel/filters/Tests/libvplot_example.c'\" unpacked with wrong size!
  574. fi
  575. # end of 'Vplot_Kernel/filters/Tests/libvplot_example.c'
  576. fi
  577. if test -f 'Vplot_Kernel/filters/genlib/genhatch.c' -a "${1}" != "-c" ; then 
  578.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/genlib/genhatch.c'\"
  579. else
  580. echo shar: Extracting \"'Vplot_Kernel/filters/genlib/genhatch.c'\" \(5398 characters\)
  581. sed "s/^X//" >'Vplot_Kernel/filters/genlib/genhatch.c' <<'END_OF_FILE'
  582. X/*
  583. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  584. X * University. Official permission to use this software is included in
  585. X * the documentation. It authorizes you to use this file for any
  586. X * non-commercial purpose, provided that this copyright notice is not
  587. X * removed and that any modifications made to this file are commented
  588. X * and dated in the style of my example below.
  589. X */
  590. X
  591. X/*
  592. X *
  593. X *  source file:   ./filters/genlib/genhatch.c
  594. X *
  595. X * Joe Dellinger (SEP), June 11 1987
  596. X *    Inserted this sample edit history entry.
  597. X *    Please log any further modifications made to this file:
  598. X * Joe Dellinger, Feb 16 1988
  599. X *    Make number of arguments to dev.attributes consistent.
  600. X */
  601. X
  602. X#include <stdio.h>
  603. X#include <math.h>
  604. X#include "../include/enum.h"
  605. X#include "../include/vertex.h"
  606. X#include "../include/params.h"
  607. X#include "../include/extern.h"
  608. X#include "../include/attrcom.h"
  609. X
  610. extern int      cur_color;
  611. extern int      need_devcolor;
  612. extern char    *malloc ();
  613. X
  614. genhatch (npts, numhatch, angle, hafat, hacol, haoff, hasiz, head)
  615. X    int             npts, numhatch;
  616. X    struct vertex  *head;
  617. X    float           angle;
  618. X    int            *hafat, *hacol, *haoff, *hasiz;
  619. X{
  620. register int    x, y, i;
  621. int             xstr, xend, ystr, yend, y1, y2, x1, x2, start;
  622. int             xa[4], ya[4], xwmin_r, xwmax_r, ywmin_r, ywmax_r;
  623. int             skip, which_time;
  624. int             ncross;
  625. int             vminx, vmaxx, vminy, vmaxy;
  626. struct vertex  *xhead, *yhead, *v;
  627. int            *crosses;
  628. int             cur_color_save;
  629. X
  630. X    cur_color_save = cur_color;
  631. X
  632. X    v = head;
  633. X    for (i = 0; i < npts; i++)
  634. X    {
  635. X    poly_rot (angle, &v->x, &v->y);
  636. X    v++;
  637. X    }
  638. X
  639. X    /*
  640. X     * allocate storage for scan line cross points 
  641. X     */
  642. X    crosses = (int *) malloc ((unsigned) npts * sizeof (int));
  643. X
  644. X    /*
  645. X     * double link the vertices. (head) is set to the node with the maximum
  646. X     * x-value so that intersect() will not eliminate 'head' while casting
  647. X     * off vertices. 
  648. X     */
  649. X    vminx = head->x;
  650. X    vmaxx = head->x;
  651. X    vminy = head->y;
  652. X    vmaxy = head->y;
  653. X    xhead = head;
  654. X    yhead = head;
  655. X
  656. X    v = head;
  657. X    for (i = 0; i < npts; i++)
  658. X    {
  659. X    if (v->x > vmaxx)
  660. X    {
  661. X        vmaxx = v->x;
  662. X        xhead = v;
  663. X    }
  664. X    if (v->y > vmaxy)
  665. X    {
  666. X        vmaxy = v->y;
  667. X        yhead = v;
  668. X    }
  669. X    if (v->x < vminx)
  670. X        vminx = v->x;
  671. X    if (v->y < vminy)
  672. X        vminy = v->y;
  673. X    v++;
  674. X    }
  675. X
  676. X/*
  677. X * Find a new window which contains the old, rotated window
  678. X */
  679. X    xwmin_r = xa[0] = xa[1] = xwmin;
  680. X    xwmax_r = xa[2] = xa[3] = xwmax;
  681. X    ywmin_r = ya[0] = ya[3] = ywmin;
  682. X    ywmax_r = ya[1] = ya[2] = ywmax;
  683. X    for (i = 0; i < 4; i++)
  684. X    {
  685. X    poly_rot (angle, &xa[i], &ya[i]);
  686. X    if (xwmin_r > xa[i])
  687. X        xwmin_r = xa[i];
  688. X    if (ywmin_r > ya[i])
  689. X        ywmin_r = ya[i];
  690. X    if (xwmax_r < xa[i])
  691. X        xwmax_r = xa[i];
  692. X    if (ywmax_r < ya[i])
  693. X        ywmax_r = ya[i];
  694. X    }
  695. X
  696. X    if (vmaxx > xwmax_r)
  697. X    vmaxx = xwmax_r;
  698. X    if (vminx < xwmin_r)
  699. X    vminx = xwmin_r;
  700. X    if (vmaxy > ywmax_r)
  701. X    vmaxy = ywmax_r;
  702. X    if (vminy < ywmin_r)
  703. X    vminy = ywmin_r;
  704. X
  705. X    /* stretch polygon in y-direction */
  706. X    v = yhead;
  707. X    do
  708. X    {
  709. X    v->y = 2 * (v->y) + 1;
  710. X    v = v->next;
  711. X    } while (v != yhead);
  712. X
  713. X    for (which_time = numhatch; which_time < 2 * numhatch; which_time++)
  714. X    {
  715. X    if (hasiz[which_time] > 0)
  716. X    {
  717. X        if (cur_color != hacol[which_time] || need_devcolor)
  718. X        {
  719. X        cur_color = hacol[which_time];
  720. X        dev.attributes (SET_COLOR, cur_color, 0, 0, 0);
  721. X        need_devcolor = NO;
  722. X        }
  723. X
  724. X        skip = hasiz[which_time];
  725. X        start = haoff[which_time] + skip * (int) (vminy / skip);
  726. X        for (y = start; y <= vmaxy; y += skip)
  727. X        {
  728. X        ncross = intersect (2 * y, crosses, yhead, 1);
  729. X        sort (crosses, ncross);
  730. X        for (i = 0; i < ncross; i += 2)
  731. X        {
  732. X            xstr = crosses[i];
  733. X            xend = crosses[i + 1];
  734. X            y1 = y2 = y;
  735. X            poly_rot (-angle, &xstr, &y1);
  736. X            poly_rot (-angle, &xend, &y2);
  737. X            dev.vector (xstr, y1, xend, y2, hafat[which_time], 0);
  738. X        }
  739. X        }
  740. X    }
  741. X    }
  742. X    /* shrink in y */
  743. X    v = yhead;
  744. X    do
  745. X    {
  746. X    v->y = ((v->y - 1) / 2);
  747. X    v = v->next;
  748. X    } while (v != yhead);
  749. X
  750. X    /*
  751. X     * expand in x 
  752. X     */
  753. X    v = xhead;
  754. X    do
  755. X    {
  756. X    v->x = 2 * v->x + 1;
  757. X    v = v->next;
  758. X    } while (v != xhead);
  759. X
  760. X    for (which_time = 0; which_time < numhatch; which_time++)
  761. X    {
  762. X    if (hasiz[which_time] > 1)
  763. X    {
  764. X        if (cur_color != hacol[which_time] || need_devcolor)
  765. X        {
  766. X        cur_color = hacol[which_time];
  767. X        dev.attributes (SET_COLOR, cur_color, 0, 0, 0);
  768. X        need_devcolor = NO;
  769. X        }
  770. X
  771. X        skip = hasiz[which_time];
  772. X        start = haoff[which_time] + skip * (int) (vminx / skip);
  773. X        for (x = start; x <= vmaxx; x += skip)
  774. X        {
  775. X        ncross = intersect (2 * x, crosses, xhead, 0);
  776. X        sort (crosses, ncross);
  777. X        for (i = 0; i < ncross; i += 2)
  778. X        {
  779. X            ystr = crosses[i];
  780. X            yend = crosses[i + 1];
  781. X            x1 = x2 = x;
  782. X            poly_rot (-angle, &x1, &ystr);
  783. X            poly_rot (-angle, &x2, ¥d);
  784. X            dev.vector (x1, ystr, x2, yend, hafat[which_time], 0);
  785. X        }
  786. X        }
  787. X
  788. X    }
  789. X    }
  790. X    /*
  791. X     * shrink in x 
  792. X     */
  793. X    v = xhead;
  794. X    do
  795. X    {
  796. X    v->x = ((v->x - 1) / 2);
  797. X    v = v->next;
  798. X    } while (v != xhead);
  799. X
  800. X    free ((char *) crosses);
  801. X
  802. X    if (cur_color != cur_color_save)
  803. X    {
  804. X    cur_color = cur_color_save;
  805. X    need_devcolor = YES;
  806. X    }
  807. X}
  808. X
  809. poly_rot (angle, x, y)
  810. X    float           angle;
  811. X    int            *x, *y;
  812. X{
  813. int             temp;
  814. X    temp = (*x * cos (angle) - *y * sin (angle)) + .5;
  815. X    *y = (*x * sin (angle) + *y * cos (angle)) + .5;
  816. X    *x = temp;
  817. X}
  818. END_OF_FILE
  819. if test 5398 -ne `wc -c <'Vplot_Kernel/filters/genlib/genhatch.c'`; then
  820.     echo shar: \"'Vplot_Kernel/filters/genlib/genhatch.c'\" unpacked with wrong size!
  821. fi
  822. # end of 'Vplot_Kernel/filters/genlib/genhatch.c'
  823. fi
  824. if test -f 'Vplot_Kernel/filters/include/attrcom.h' -a "${1}" != "-c" ; then 
  825.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/include/attrcom.h'\"
  826. else
  827. echo shar: Extracting \"'Vplot_Kernel/filters/include/attrcom.h'\" \(5514 characters\)
  828. sed "s/^X//" >'Vplot_Kernel/filters/include/attrcom.h' <<'END_OF_FILE'
  829. X/*
  830. X * commands to the device's "attributes" routine
  831. X */
  832. X
  833. X#define    SET_COLOR        1
  834. X#define SET_COLOR_TABLE     2
  835. X#define SET_WINDOW        3
  836. X#define NEW_DASH        4
  837. X#define NEW_PAT            5
  838. X#define NEW_FONT        6
  839. X#define NEW_OVERLAY        7
  840. X#define NEW_ALIGN        8
  841. X#define NEW_FAT            9
  842. X#define BEGIN_GROUP        10
  843. X#define END_GROUP        11
  844. X
  845. X#define DOVPLOT_CONT        0    /* MUST be zero */
  846. X#define DOVPLOT_EXIT        1
  847. X
  848. X/*
  849. X * Uses:
  850. X * Dummy arguments are not used, but should be listed to make some finicky
  851. X * compilers happy, even if you don't use any of the commands that require
  852. X * all 4 arguments. By the same token, you should explicitly declare a
  853. X * return value of 0 even for those calls that don't use the return value.
  854. X *
  855. X * dev.attributes(SET_COLOR, col, dummy1, dummy2, dummy3)
  856. X *
  857. X * Set the current drawing color to col. The device is assumed to
  858. X * start out with the current drawing color 7 = WHITE.
  859. X *
  860. X * dev.attributes(SET_COLOR_TABLE, col, red, green, blue)
  861. X * 
  862. X * Set color number col to have the color (red,green,blue).
  863. X * Red, green, and blue are in the range from 0 to MAX_GUN (255),
  864. X * with 0 being off and MAX_GUN being fully on.
  865. X * Thus, (0,0,0) is black, (128,128,128) is grey, (255,255,255) is white,
  866. X * (255,0,0) is red, (255,255,0) is yellow, etc... The device is assumed
  867. X * to start out with colors 0 through 7 set as in the vplot standard.
  868. X *
  869. X * dev.attributes(SET_WINDOW, xmin, ymin, xmax, ymax)
  870. X *
  871. X * Set current clipping window. (xmin,ymin) is the lower-leftmost
  872. X * displayable point. (xmax,ymax) is the upper-rightmost displayable point.
  873. X * Only necessary to support this if smart_clip=YES, smart_raster=YES, or
  874. X * you don't use a generic routine (genarea) to clip polygons for you.
  875. X * After dev.reset has been called, dovplot assumes that the clipping
  876. X * window is set by the device to the edge of the device's screen.
  877. X * Dev.attributes(SET_WINDOW, ...) will thereafter be called whenever
  878. X * the clipping window is changed from its previous setting. (Thus,
  879. X * if no clipping window is ever set at all, dev.attributes(SET_WINDOW, ...)
  880. X * will never be called.) It is possible for xmin > xmax or ymin > ymax.
  881. X * If this happens everything should be clipped away.
  882. X *
  883. X * dev.attributes(NEW_DASH, dashon, dummy1, dummy2, dummy3)
  884. X *
  885. X * Warn the device that the current dashed line pattern has just
  886. X * been changed. "dashon" is the new value of the external variable
  887. X * dashon. (See the dev.vector documentation.)
  888. X *
  889. X * dev.attributes(NEW_PAT, ipat, dummy1, dummy2, dummy3)
  890. X *
  891. X * Warn the device that raster pattern "ipat" has been defined
  892. X * or redefined. The device does not have to allow re-definition
  893. X * of defined patterns. (See the dev.area documentation for a
  894. X * description of how patterns are stored.)
  895. X *
  896. X * dev.attributes(NEW_FONT, txfont, txprec, txovly, dummy1)
  897. X *
  898. X * Warn the device that the text font, precision, or overlay may have
  899. X * been changed. A value of "-1" means no change from the previous value,
  900. X * which may be a device-dependent default. This form of dev.attributes
  901. X * will be called whenever the user uses the "set text font and precision"
  902. X * vplot command (and only then), so you probably should check to see if
  903. X * anything really changed before bothering the device. Even better,
  904. X * only check these variables at the time that you output hardware text,
  905. X * and don't bother with this option in dev.attributes at all.
  906. X *
  907. X * dev.attributes(NEW_OVERLAY, overlay, dummy1, dummy2, dummy3)
  908. X *
  909. X * Warn the device that the overlay mode may have been changed. Again,
  910. X * most devices will ignore this dev.attributes call, and check the
  911. X * external variable overlay only when they actually need to know what
  912. X * it is.
  913. X *
  914. X * dev.attributes(NEW_ALIGN, txalign.hor, txalign.ver, dummy1, dummy2)
  915. X *
  916. X * Warn the device that the text alignment mode has been changed. Again,
  917. X * most devices will ignore this call and just check the alignment
  918. X * when hardware text is drawn.
  919. X *
  920. X * dev.attributes(NEW_FAT, fat, dummy1, dummy2, dummy3)
  921. X *
  922. X * Warn the device that the fatness has been changed. Again, most devices
  923. X * should ignore this call and just check the fatness before processing
  924. X * any of the 3 things in which it is used: vectors, text, markers.
  925. X * Check the dev.vector documentation for caveats similar to those for
  926. X * the NEW_PAT case.
  927. X *
  928. X * dev.attributes(BEGIN_GROUP, group_number, pos, dummy1, dummy2)
  929. X * dev.attributes(END_GROUP, group_number, dummy1, dummy2, dummy3)
  930. X *
  931. X * extern char group_name[MAXFLEN+1];
  932. X *
  933. X * return iflag
  934. X *
  935. X * Everything between these calls is grouped as one "object".
  936. X * Objects may be nested. Objects may not extend across erases,
  937. X * breaks, or files. The name of the most recently begun object is
  938. X * stored in the external variable group_name. Group_name is defined
  939. X * in extern.h. "group_number" gives the heirarchical order of the
  940. X * object. Each plot frame is itself an object of group number 0.
  941. X * "pos" gives the offset from the start of the file of the start of
  942. X * this object. If "pos" is negative, then the input file is one
  943. X * for which seeks don't work. Dev.attributes(END_GROUP,...) returns
  944. X * "iflag" to tell dovplot what it should do next.
  945. X * If "iflag" is DOVPLOT_CONT (=0), then dovplot should continue exactly
  946. X * as normal. If "iflag" is DOVPLOT_EXIT, then dovplot will exit upon the
  947. X * return of this call. Note that K+R says that failing to declare
  948. X * a return value returns garbage, so you MUST declare a return value
  949. X * for dev.attributes(END_GROUP,...). To help make sure you do this,
  950. X * dovplot will issue a warning message if an unknown return value is
  951. X * given.
  952. X *
  953. X */
  954. END_OF_FILE
  955. if test 5514 -ne `wc -c <'Vplot_Kernel/filters/include/attrcom.h'`; then
  956.     echo shar: \"'Vplot_Kernel/filters/include/attrcom.h'\" unpacked with wrong size!
  957. fi
  958. # end of 'Vplot_Kernel/filters/include/attrcom.h'
  959. fi
  960. if test -f 'Vplot_Kernel/filters/loclib/getpar_scan.l' -a "${1}" != "-c" ; then 
  961.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/loclib/getpar_scan.l'\"
  962. else
  963. echo shar: Extracting \"'Vplot_Kernel/filters/loclib/getpar_scan.l'\" \(5332 characters\)
  964. sed "s/^X//" >'Vplot_Kernel/filters/loclib/getpar_scan.l' <<'END_OF_FILE'
  965. X%C
  966. NONWHITE    [^ \t\n]
  967. ALPHA    [A-Za-z]
  968. ALPHANUM    [A-Za-z0-9_-]
  969. TAG    {ALPHA}{ALPHANUM}*=
  970. SQ    \'([^'\n]*\'\')*[^'\n]*['\n]
  971. DQ    \"([^"\n]*\"\")*[^"\n]*["\n]
  972. X%{
  973. X/* lexical scanning for fast getpar */
  974. X/* Revised 3-8-86 stew  Added time stamp to enable older method of handling
  975. X *            multiple tags.  Moved par= intiialization to
  976. X *            separate routine to avoid code duplication.
  977. X */
  978. X#include <ctype.h>
  979. X#include "fastpar.h"
  980. X#undef input
  981. X#define input() ((int) *(input_stack[input_depth]++))
  982. X#undef unput
  983. X/* The redundant  =(c) insures side effects of expressions occur */
  984. X#define unput(c) (*(--(input_stack[input_depth]))=(c))
  985. X#define yywrap() getpar_pop_input()
  986. X#define yylex() getpar_lexscan()
  987. X#define yylook() getpar_yylook()
  988. X
  989. X#define MAX_INPUT_DEPTH 10
  990. static int input_depth = -1;
  991. static char *input_stack[MAX_INPUT_DEPTH];
  992. static char *dealloc_stack[MAX_INPUT_DEPTH];
  993. X
  994. static struct {
  995. X    char *tag;  int tlen;
  996. X    char *val;  int vlen;
  997. X       } yy;
  998. X
  999. X
  1000. static int  SMALLBLOCK = 4096;
  1001. static char
  1002. X*suballoc (size)
  1003. int size;
  1004. X{
  1005. X    static char *myblock = (char *) NULL; static int bytesleft = 0;
  1006. X    char *ptr; extern char *alloc();
  1007. X
  1008. X    if(size > SMALLBLOCK) return(alloc(size));
  1009. X    else
  1010. X      { 
  1011. X        if(bytesleft < size)
  1012. X           {
  1013. X            myblock = alloc (SMALLBLOCK);
  1014. X        bytesleft = SMALLBLOCK - size;
  1015. X           }
  1016. X       else
  1017. X           {
  1018. X        bytesleft -= size;
  1019. X           }
  1020. X       ptr = myblock;
  1021. X       myblock += size;
  1022. X       return(ptr);
  1023. X      }
  1024. X}
  1025. X
  1026. static int  prime[10] = {31,29,23,19,17,13,11,7,5,3};
  1027. int getpar_hash(array,len)
  1028. register char *array;
  1029. register int len;
  1030. X{
  1031. X  register int hash;
  1032. X  register int i;
  1033. X  if(len >10) len=10;
  1034. X  hash=0;
  1035. X  for(i=0; i<len; i++)
  1036. X    hash += array[i]*prime[i];
  1037. X  return(hash);
  1038. X}
  1039. X
  1040. X/* workhorse to decode par files; shell already parses command line */
  1041. getpar_scan(queue,qlen)
  1042. register hash_item **queue;
  1043. register int qlen;
  1044. X{
  1045. X extern int yylex();
  1046. X
  1047. X while(yylex()) {
  1048. X    getpar_hash_store(queue,qlen,yy.tag,yy.val,yy.tlen,yy.vlen);
  1049. X    if(yy.tlen == 3 && 0 == bcmp(yy.tag,"par",3))
  1050. X        getpar_stack_par(yy.val);
  1051. X    }
  1052. X}
  1053. X
  1054. X/* read parfile into core and put buffer on scan input stack */
  1055. getpar_stack_par(val)
  1056. char *val;
  1057. X{
  1058. X register char *buffer;
  1059. X register int fd, len;
  1060. X extern int file(), fsize();
  1061. X extern char *alloc();
  1062. X
  1063. X    fd = file(val,0);
  1064. X    len = fsize(fd);
  1065. X    buffer=alloc(len+3);
  1066. X    buffer[0]='\n';
  1067. X    read(fd,buffer+1,len);
  1068. X    buffer[len+1]='\n';
  1069. X    buffer[len+2]='\0';
  1070. X    getpar_push_input(buffer,1);
  1071. X    close(fd);
  1072. X}
  1073. X
  1074. X /* return 1 if match; 0 otherwise */
  1075. X#define getpar_hash_compare(next1,tag1,tlen1)  \
  1076. X ((next1)->tlen == (tlen1) && 0 == bcmp((next1)->tag,tag1,tlen1))
  1077. X
  1078. getpar_hash_store(q,qlen,tag,val,tlen,vlen)
  1079. hash_item **q;
  1080. register char *tag, *val;
  1081. register int tlen;
  1082. int qlen, vlen;
  1083. X{
  1084. X register hash_item *hold, *next;
  1085. X static int storetime = 0;
  1086. X
  1087. X hold=(hash_item *) (q+getpar_hash(tag,tlen)%qlen);
  1088. X next=hold->next;
  1089. X
  1090. X while(next != ((hash_item *) NULL)) {
  1091. X    if(getpar_hash_compare(next,tag,tlen) ) {
  1092. X        next->val = val; next->vlen = vlen;
  1093. X        next->timestamp = storetime++; return;
  1094. X        }
  1095. X    hold = next; next = next->next;
  1096. X    }
  1097. X
  1098. X hold->next = next = (hash_item *) suballoc(sizeof(hash_item));
  1099. X next->next = (hash_item *) NULL;
  1100. X next->tlen = tlen;
  1101. X next->tag = tag;
  1102. X next->vlen = vlen;
  1103. X next->val = val;
  1104. X next->timestamp = storetime++;
  1105. X}
  1106. X
  1107. hash_item *getpar_hash_lookup(q,qlen,tag,tlen)
  1108. register hash_item **q;
  1109. register char *tag;
  1110. register int tlen;
  1111. register int qlen;
  1112. X{
  1113. X register hash_item *next;
  1114. X
  1115. X next = *(q + getpar_hash(tag,tlen)%qlen);
  1116. X
  1117. X while(next != ((hash_item *) NULL) ) {
  1118. X    if(getpar_hash_compare(next,tag,tlen)) break;
  1119. X    next = next->next;
  1120. X    }
  1121. X return(next);
  1122. X}
  1123. X
  1124. X%}
  1125. X%S FOUNDTAG
  1126. X%%
  1127. X<FOUNDTAG>{SQ}        {
  1128. X             yy.vlen = yyleng-2; yy.val=suballoc(yy.vlen+1);
  1129. X             yy.vlen = massage(yytext+1,yy.val,yy.vlen,yytext[0]);
  1130. X             yy.val[yy.vlen]='\0'; BEGIN 0; return(FOUNDTAG);
  1131. X             }
  1132. X<FOUNDTAG>{DQ}        {
  1133. X             yy.vlen = yyleng-2; yy.val=suballoc(yy.vlen+1);
  1134. X             yy.vlen = massage(yytext+1,yy.val,yy.vlen,yytext[0]);
  1135. X             yy.val[yy.vlen]='\0'; BEGIN 0; return(FOUNDTAG);
  1136. X             }
  1137. X<FOUNDTAG>[^'"]{NONWHITE}*    {
  1138. X                 yy.vlen=yyleng; yy.val=suballoc(yy.vlen+1);
  1139. X                  bcopy(yytext,yy.val,yy.vlen+1); BEGIN 0;
  1140. X                 return(FOUNDTAG);
  1141. X                 }
  1142. X^{TAG}/{NONWHITE}    {
  1143. X             yy.tlen=yyleng-1; yy.tag=suballoc(yy.tlen+1);
  1144. X             bcopy(yytext,yy.tag,yy.tlen);
  1145. X             yy.tag[yy.tlen]='\0'; BEGIN FOUNDTAG;
  1146. X             }
  1147. X([ \t]{TAG})/{NONWHITE}    {
  1148. X             yy.tlen=yyleng-2; yy.tag=suballoc(yy.tlen+1);
  1149. X             bcopy(yytext+1,yy.tag,yy.tlen);
  1150. X             yy.tag[yy.tlen]='\0'; BEGIN FOUNDTAG;
  1151. X             }
  1152. X^\#.*    /* skip comment lines */;
  1153. X.    |
  1154. X\n    ;
  1155. X%%
  1156. X    getpar_push_input(buffer,dealloc)
  1157. X    register char *buffer;
  1158. X    register int dealloc;
  1159. X    {
  1160. X      if(input_depth++ == MAX_INPUT_DEPTH)
  1161. X        err("too many nested par files\n");
  1162. X      input_stack[input_depth] = buffer;
  1163. X      if(dealloc) dealloc_stack[input_depth] = buffer;
  1164. X      else dealloc_stack[input_depth] = (char *) NULL;
  1165. X    }
  1166. X
  1167. X    int
  1168. X    yywrap()
  1169. X    {
  1170. X      if(((char *) NULL) != dealloc_stack[input_depth]) {
  1171. X        free(dealloc_stack[input_depth]);
  1172. X        dealloc_stack[input_depth] = (char *) NULL;
  1173. X        }
  1174. X      input_stack[input_depth--] = (char *) NULL;
  1175. X      if(input_depth < 0) return(1);
  1176. X      return(0);
  1177. X    }
  1178. X
  1179. X    static int
  1180. X    massage(string,out,len,quote)
  1181. X    register char *string, *out;
  1182. X    register int len, quote;
  1183. X    {
  1184. X     register int i,j;
  1185. X    
  1186. X    for(i=0,j=0; i<len-1; j++) {
  1187. X        out[j]=string[i++];
  1188. X        if(out[j]==quote) /* compress doubled quotes */
  1189. X            if(string[i]==quote) i++;
  1190. X        }
  1191. X    if(i<len) out[j++] = string[i];
  1192. X    return(j);
  1193. X    }
  1194. END_OF_FILE
  1195. if test 5332 -ne `wc -c <'Vplot_Kernel/filters/loclib/getpar_scan.l'`; then
  1196.     echo shar: \"'Vplot_Kernel/filters/loclib/getpar_scan.l'\" unpacked with wrong size!
  1197. fi
  1198. # end of 'Vplot_Kernel/filters/loclib/getpar_scan.l'
  1199. fi
  1200. if test -f 'Vplot_Kernel/filters/utilities/dither.c' -a "${1}" != "-c" ; then 
  1201.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/utilities/dither.c'\"
  1202. else
  1203. echo shar: Extracting \"'Vplot_Kernel/filters/utilities/dither.c'\" \(5256 characters\)
  1204. sed "s/^X//" >'Vplot_Kernel/filters/utilities/dither.c' <<'END_OF_FILE'
  1205. X/*
  1206. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  1207. X * University. Official permission to use this software is included in
  1208. X * the documentation. It authorizes you to use this file for any
  1209. X * non-commercial purpose, provided that this copyright notice is not
  1210. X * removed and that any modifications made to this file are commented
  1211. X * and dated in the style of my example below.
  1212. X */
  1213. X
  1214. X/*
  1215. X *
  1216. X *  source file:   ./filters/utilities/dither.c
  1217. X *
  1218. X * Joe Dellinger (SEP), June 11 1987
  1219. X *    Inserted this sample edit history entry.
  1220. X *    Please log any further modifications made to this file:
  1221. X * Steve Cole (SEP), September 1 1987
  1222. X *      Added method 4 (digital halftoning).
  1223. X */
  1224. X
  1225. X/*
  1226. X * this subroutine converts a single raster line to single bit
  1227. X * using one of the following algorithms:
  1228. X *
  1229. X * 1 random threshold
  1230. X * 2 256 element ordered dither (oriented at 0 degrees)
  1231. X * 3 Floyd-Steinberg minimized average error method
  1232. X * 4 32 element halftone (oriented at 45 degrees)
  1233. X *
  1234. X * Steve Cole, April 1987
  1235. X *
  1236. X */
  1237. X#include <stdio.h>
  1238. X#include "../include/err.h"
  1239. X#include "../include/params.h"
  1240. X#include "../include/extern.h"
  1241. static int      pix_on, pix_off;
  1242. char           *malloc ();
  1243. static float   *errline;
  1244. static int      ialloc;
  1245. static float    alpha = 0.4375;
  1246. static float    beta = 0.1875;
  1247. static float    gamma = 0.3125;
  1248. static float    delta = 0.0625;
  1249. static int      dith256[256] = {
  1250. X    1, 128, 32, 160, 8, 136, 40, 168, 2, 130, 34, 162, 10, 138, 42, 170,
  1251. X   192, 64, 224, 96, 200, 72, 232, 104, 194, 66, 226, 98, 202, 74, 234, 106,
  1252. X     48, 176, 16, 144, 56, 184, 24, 152, 50, 178, 18, 146, 58, 186, 26, 154,
  1253. X 240, 112, 208, 80, 248, 120, 216, 88, 242, 114, 210, 82, 250, 122, 218, 90,
  1254. X       12, 140, 44, 172, 4, 132, 36, 164, 14, 142, 46, 174, 6, 134, 38, 166,
  1255. X 204, 76, 236, 108, 196, 68, 228, 100, 206, 78, 238, 110, 198, 70, 230, 102,
  1256. X     60, 188, 28, 156, 52, 180, 20, 148, 62, 190, 30, 158, 54, 182, 22, 150,
  1257. X 252, 124, 220, 92, 244, 116, 212, 84, 254, 126, 222, 94, 246, 118, 214, 86,
  1258. X    3, 131, 35, 163, 11, 139, 43, 171, 1, 129, 33, 161, 9, 137, 41, 169,
  1259. X   195, 67, 227, 99, 203, 75, 235, 107, 193, 65, 225, 97, 201, 73, 233, 105,
  1260. X     51, 179, 19, 147, 59, 187, 27, 155, 49, 177, 17, 145, 57, 185, 25, 153,
  1261. X 243, 115, 211, 83, 251, 123, 219, 91, 241, 113, 209, 81, 249, 121, 217, 89,
  1262. X       15, 143, 47, 175, 7, 135, 39, 167, 13, 141, 45, 173, 5, 133, 37, 165,
  1263. X 207, 79, 239, 111, 199, 71, 231, 103, 205, 77, 237, 109, 197, 69, 229, 101,
  1264. X     63, 191, 31, 159, 55, 183, 23, 151, 61, 189, 29, 157, 53, 181, 21, 149,
  1265. X  254, 127, 223, 95, 247, 119, 215, 87, 253, 125, 221, 93, 245, 117, 213, 85
  1266. X};
  1267. static int      halftone32[64] = {
  1268. X                  92, 100, 124, 148, 164, 156, 132, 108,
  1269. X                  28, 20, 76, 220, 228, 236, 180, 36,
  1270. X                  4, 12, 84, 212, 252, 244, 172, 44,
  1271. X                  52, 60, 116, 188, 204, 196, 140, 68,
  1272. X                  164, 156, 132, 108, 92, 100, 124, 148,
  1273. X                  228, 236, 180, 36, 28, 20, 76, 220,
  1274. X                  252, 244, 172, 44, 4, 12, 84, 212,
  1275. X                  204, 196, 140, 68, 52, 60, 116, 188
  1276. X};
  1277. X
  1278. X
  1279. dithline (inline, outline, npixels, linenum, imethod)
  1280. X    unsigned char  *inline, *outline;
  1281. X    int             npixels, linenum, imethod;
  1282. X{
  1283. int             greydata;
  1284. int             i1, ipoint, jpoint;
  1285. float           pixel, pixerr, nexterr;
  1286. int             irand;
  1287. X
  1288. X/* set polarity */
  1289. X    if (linenum == 1)
  1290. X    {
  1291. X    if (invras)
  1292. X    {
  1293. X        pix_off = 0;
  1294. X        pix_on = 7;
  1295. X    }
  1296. X    else
  1297. X    {
  1298. X        pix_off = 7;
  1299. X        pix_on = 0;
  1300. X    }
  1301. X    }
  1302. X
  1303. X/* Random Dither */
  1304. X    if (imethod == 1)
  1305. X    {
  1306. X    for (i1 = 0; i1 < npixels; i1++)
  1307. X    {
  1308. X        greydata = inline[i1];
  1309. X        irand = (random () & 255);
  1310. X        if (greydata > irand)
  1311. X        {
  1312. X        outline[i1] = pix_off;
  1313. X        }
  1314. X        else
  1315. X        {
  1316. X        outline[i1] = pix_on;
  1317. X        }
  1318. X    }
  1319. X    }
  1320. X
  1321. X/* Ordered Dither */
  1322. X    if (imethod == 2)
  1323. X    {
  1324. X    for (i1 = 0; i1 < npixels; i1++)
  1325. X    {
  1326. X        greydata = inline[i1];
  1327. X        ipoint = i1 % 16;
  1328. X        jpoint = linenum % 16;
  1329. X        ipoint = ipoint * 16 + jpoint;
  1330. X        if (greydata > dith256[ipoint])
  1331. X        {
  1332. X        outline[i1] = pix_off;
  1333. X        }
  1334. X        else
  1335. X        {
  1336. X        outline[i1] = pix_on;
  1337. X        }
  1338. X    }
  1339. X    }
  1340. X
  1341. X/* Floyd-Steinberg */
  1342. X    if (imethod == 3)
  1343. X    {
  1344. X    if (ialloc != 1)
  1345. X    {
  1346. X        if ((errline = (float *) malloc ((unsigned) npixels * sizeof (float))) == NULL)
  1347. X        {
  1348. X        ERR (FATAL, name, "Can't allocate space for Floyd-Steinberg\n");
  1349. X        return;
  1350. X        }
  1351. X        ialloc = 1;
  1352. X        for (i1 = 0; i1 < npixels; i1++)
  1353. X        {
  1354. X        errline[i1] = 0.;
  1355. X        }
  1356. X    }
  1357. X    nexterr = errline[0];
  1358. X    for (i1 = 0; i1 < npixels; i1++)
  1359. X    {
  1360. X        pixel = inline[i1];
  1361. X        pixel += nexterr;
  1362. X        if (pixel < 128)
  1363. X        {
  1364. X        outline[i1] = pix_on;
  1365. X        pixerr = pixel;
  1366. X        }
  1367. X        else
  1368. X        {
  1369. X        outline[i1] = pix_off;
  1370. X        pixerr = pixel - 255;
  1371. X        }
  1372. X        if (i1 < npixels)
  1373. X        {
  1374. X        nexterr = errline[i1 + 1] + pixerr * alpha;
  1375. X        errline[i1 + 1] = pixerr * delta;
  1376. X        }
  1377. X        if (i1 > 0)
  1378. X        {
  1379. X        errline[i1 - 1] += pixerr * beta;
  1380. X        }
  1381. X        errline[i1] += pixerr * gamma;
  1382. X        if (i1 == 0)
  1383. X        errline[i1] = pixerr * gamma;
  1384. X    }
  1385. X    }
  1386. X
  1387. X
  1388. X/* 32 element halftone at 45 degrees */
  1389. X    if (imethod == 4)
  1390. X    {
  1391. X    for (i1 = 0; i1 < npixels; i1++)
  1392. X    {
  1393. X        greydata = inline[i1];
  1394. X        ipoint = i1 % 8;
  1395. X        jpoint = linenum % 8;
  1396. X        ipoint = ipoint * 8 + jpoint;
  1397. X        if (greydata > halftone32[ipoint])
  1398. X        {
  1399. X        outline[i1] = pix_off;
  1400. X        }
  1401. X        else
  1402. X        {
  1403. X        outline[i1] = pix_on;
  1404. X        }
  1405. X    }
  1406. X    }
  1407. X
  1408. X}
  1409. END_OF_FILE
  1410. if test 5256 -ne `wc -c <'Vplot_Kernel/filters/utilities/dither.c'`; then
  1411.     echo shar: \"'Vplot_Kernel/filters/utilities/dither.c'\" unpacked with wrong size!
  1412. fi
  1413. # end of 'Vplot_Kernel/filters/utilities/dither.c'
  1414. fi
  1415. if test -f 'Vplot_Kernel/filters/utilities/fatvec.c' -a "${1}" != "-c" ; then 
  1416.   echo shar: Will not clobber existing file \"'Vplot_Kernel/filters/utilities/fatvec.c'\"
  1417. else
  1418. echo shar: Extracting \"'Vplot_Kernel/filters/utilities/fatvec.c'\" \(5227 characters\)
  1419. sed "s/^X//" >'Vplot_Kernel/filters/utilities/fatvec.c' <<'END_OF_FILE'
  1420. X/*
  1421. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  1422. X * University. Official permission to use this software is included in
  1423. X * the documentation. It authorizes you to use this file for any
  1424. X * non-commercial purpose, provided that this copyright notice is not
  1425. X * removed and that any modifications made to this file are commented
  1426. X * and dated in the style of my example below.
  1427. X */
  1428. X
  1429. X/*
  1430. X *
  1431. X *  source file:   ./filters/utilities/fatvec.c
  1432. X *
  1433. X * Joe Dellinger (SEP), June 11 1987
  1434. X *    Inserted this sample edit history entry.
  1435. X *    Please log any further modifications made to this file:
  1436. X */
  1437. X
  1438. X/*
  1439. X * Utility routine to make fat vectors from several thin ones.
  1440. X * Should ONLY be called if nfat > 0 and dashon = 0
  1441. X *
  1442. X * Algorithm by Glenn Kroeger
  1443. X * Changes added by Joe Dellinger to make it more efficient when plotting
  1444. X */
  1445. X
  1446. X#include <stdio.h>
  1447. X#include <math.h>
  1448. X#include "../include/extern.h"
  1449. X
  1450. fatvec (x1, y1, x2, y2, nfat, dashon)
  1451. X    int             x1, y1, x2, y2;
  1452. X    int             nfat, dashon;
  1453. X{
  1454. register int    i;
  1455. register int    fplus, fminus;
  1456. static int      lastdir = 0;
  1457. X
  1458. X    lastdir = 1 - lastdir;
  1459. X
  1460. X    if (aspect_ratio != 1. && (y2 != y1 || x2 != x1) && nfat)
  1461. X    {
  1462. nfat = (float) nfat *sqrt (
  1463. X                        ((y2 - y1) * (y2 - y1) + ((x2 - x1) * (x2 - x1))
  1464. X                 /               (aspect_ratio * aspect_ratio)) /
  1465. X                       ((y2 - y1) * (y2 - y1) + ((x2 - x1) * (x2 - x1)))
  1466. X    );
  1467. X    }
  1468. X
  1469. X    fminus = (nfat / 2);
  1470. X    fplus = (nfat + 1) / 2;
  1471. X
  1472. X    if (x1 <= x2)
  1473. X    {
  1474. X    if (y2 > y1)
  1475. X    {
  1476. X        if (x1 == x2)
  1477. X        {
  1478. X        for (i = -fminus; i <= fplus; i++)
  1479. X            dev.vector (x1 + i, y1 - fminus, x2 + i, y2 + fplus, 0, 0);
  1480. X        }
  1481. X        else
  1482. X        {
  1483. X
  1484. X        if (lastdir)
  1485. X        {
  1486. X            for (i = (fminus + fplus); i > 0; i--)
  1487. X            {
  1488. X            dev.vector (x1 - fminus + i, y1 - fminus, x2 + fplus,
  1489. X                    y2 + fplus - i, 0, 0);
  1490. X            }
  1491. X            dev.vector (x1 - fminus, y1 - fminus, x2 + fplus, y2 + fplus, 0, 0);
  1492. X            for (i = 1; i < (fminus + fplus + 1); i++)
  1493. X            {
  1494. X            dev.vector (x1 - fminus, y1 - fminus + i, x2 + fplus - i,
  1495. X                    y2 + fplus, 0, 0);
  1496. X            }
  1497. X        }
  1498. X        else
  1499. X        {
  1500. X            for (i = (fminus + fplus); i > 0; i--)
  1501. X            {
  1502. X            dev.vector (x1 - fminus, y1 - fminus + i, x2 + fplus - i,
  1503. X                    y2 + fplus, 0, 0);
  1504. X            }
  1505. X            dev.vector (x1 - fminus, y1 - fminus, x2 + fplus, y2 + fplus, 0, 0);
  1506. X            for (i = 1; i < (fminus + fplus + 1); i++)
  1507. X            {
  1508. X            dev.vector (x1 - fminus + i, y1 - fminus, x2 + fplus,
  1509. X                    y2 + fplus - i, 0, 0);
  1510. X            }
  1511. X        }
  1512. X        }
  1513. X    }
  1514. X    else
  1515. X    if (y2 == y1)
  1516. X    {
  1517. X        for (i = -fminus; i <= fplus; i++)
  1518. X        dev.vector (x1 - fminus, y1 + i, x2 + fplus, y2 + i, 0, 0);
  1519. X    }
  1520. X    else
  1521. X    {
  1522. X        if (x1 == x2)
  1523. X        {
  1524. X        for (i = -fminus; i <= fplus; i++)
  1525. X            dev.vector (x1 + i, y1 + fplus, x2 + i, y2 - fminus, 0, 0);
  1526. X        }
  1527. X        else
  1528. X        {
  1529. X
  1530. X        if (lastdir)
  1531. X        {
  1532. X            for (i = (fminus + fplus); i > 0; i--)
  1533. X            {
  1534. X            dev.vector (x1 - fminus + i, y1 + fplus, x2 + fplus,
  1535. X                    y2 - fminus + i, 0, 0);
  1536. X            }
  1537. X            dev.vector (x1 - fminus, y1 + fplus, x2 + fplus, y2 - fminus, 0, 0);
  1538. X            for (i = 1; i < (fminus + fplus + 1); i++)
  1539. X            {
  1540. X            dev.vector (x1 - fminus, y1 + fplus - i, x2 + fplus - i,
  1541. X                    y2 - fminus, 0, 0);
  1542. X            }
  1543. X        }
  1544. X        else
  1545. X        {
  1546. X            for (i = (fminus + fplus); i > 0; i--)
  1547. X            {
  1548. X            dev.vector (x1 - fminus, y1 + fplus - i, x2 + fplus - i,
  1549. X                    y2 - fminus, 0, 0);
  1550. X            }
  1551. X            dev.vector (x1 - fminus, y1 + fplus, x2 + fplus, y2 - fminus, 0, 0);
  1552. X            for (i = 1; i < (fminus + fplus + 1); i++)
  1553. X            {
  1554. X            dev.vector (x1 - fminus + i, y1 + fplus, x2 + fplus,
  1555. X                    y2 - fminus + i, 0, 0);
  1556. X            }
  1557. X        }
  1558. X        }
  1559. X    }
  1560. X    }
  1561. X    else
  1562. X    {
  1563. X    if (y2 > y1)
  1564. X    {
  1565. X        if (lastdir)
  1566. X        {
  1567. X        for (i = (fminus + fplus); i > 0; i--)
  1568. X        {
  1569. X            dev.vector (x1 + fplus, y1 - fminus + i, x2 - fminus + i, y2 + fplus, 0, 0);
  1570. X        }
  1571. X        dev.vector (x1 + fplus, y1 - fminus, x2 - fminus, y2 + fplus, 0, 0);
  1572. X        for (i = 1; i < (fminus + fplus + 1); i++)
  1573. X        {
  1574. X            dev.vector (x1 + fplus - i, y1 - fminus, x2 - fminus, y2 + fplus - i, 0, 0);
  1575. X        }
  1576. X        }
  1577. X        else
  1578. X        {
  1579. X        for (i = (fminus + fplus); i > 0; i--)
  1580. X        {
  1581. X            dev.vector (x1 + fplus - i, y1 - fminus, x2 - fminus, y2 + fplus - i, 0, 0);
  1582. X        }
  1583. X        dev.vector (x1 + fplus, y1 - fminus, x2 - fminus, y2 + fplus, 0, 0);
  1584. X        for (i = 1; i < (fminus + fplus + 1); i++)
  1585. X        {
  1586. X            dev.vector (x1 + fplus, y1 - fminus + i, x2 - fminus + i, y2 + fplus, 0, 0);
  1587. X        }
  1588. X        }
  1589. X    }
  1590. X    else
  1591. X    if (y2 == y1)
  1592. X    {
  1593. X        for (i = -fminus; i <= fplus; i++)
  1594. X        dev.vector (x1 + fplus, y1 + i, x2 - fminus, y2 + i, 0, 0);
  1595. X    }
  1596. X    else
  1597. X    {
  1598. X        if (lastdir)
  1599. X        {
  1600. X        for (i = (fminus + fplus); i > 0; i--)
  1601. X        {
  1602. X            dev.vector (x1 + fplus, y1 + fplus - i, x2 - fminus + i, y2 - fminus, 0, 0);
  1603. X        }
  1604. X        dev.vector (x1 + fplus, y1 + fplus, x2 - fminus, y2 - fminus, 0, 0);
  1605. X        for (i = 1; i < (fminus + fplus + 1); i++)
  1606. X        {
  1607. X            dev.vector (x1 + fplus - i, y1 + fplus, x2 - fminus, y2 - fminus + i, 0, 0);
  1608. X        }
  1609. X        }
  1610. X        else
  1611. X        {
  1612. X        for (i = (fminus + fplus); i > 0; i--)
  1613. X        {
  1614. X            dev.vector (x1 + fplus - i, y1 + fplus, x2 - fminus, y2 - fminus + i, 0, 0);
  1615. X        }
  1616. X        dev.vector (x1 + fplus, y1 + fplus, x2 - fminus, y2 - fminus, 0, 0);
  1617. X        for (i = 1; i < (fminus + fplus + 1); i++)
  1618. X        {
  1619. X            dev.vector (x1 + fplus, y1 + fplus - i, x2 - fminus + i, y2 - fminus, 0, 0);
  1620. X        }
  1621. X        }
  1622. X    }
  1623. X    }
  1624. X}
  1625. END_OF_FILE
  1626. if test 5227 -ne `wc -c <'Vplot_Kernel/filters/utilities/fatvec.c'`; then
  1627.     echo shar: \"'Vplot_Kernel/filters/utilities/fatvec.c'\" unpacked with wrong size!
  1628. fi
  1629. # end of 'Vplot_Kernel/filters/utilities/fatvec.c'
  1630. fi
  1631. if test -f 'Vplot_Kernel/lvplot/vp_raster.c' -a "${1}" != "-c" ; then 
  1632.   echo shar: Will not clobber existing file \"'Vplot_Kernel/lvplot/vp_raster.c'\"
  1633. else
  1634. echo shar: Extracting \"'Vplot_Kernel/lvplot/vp_raster.c'\" \(5777 characters\)
  1635. sed "s/^X//" >'Vplot_Kernel/lvplot/vp_raster.c' <<'END_OF_FILE'
  1636. X/*
  1637. X * Copyright 1987 the Board of Trustees of the Leland Stanford Junior
  1638. X * University. Official permission to use this software is included in
  1639. X * the documentation. It authorizes you to use this file for any
  1640. X * non-commercial purpose, provided that this copyright notice is not
  1641. X * removed and that any modifications made to this file are commented
  1642. X * and dated in the style of my example below.
  1643. X */
  1644. X
  1645. X/*
  1646. X *
  1647. X *  source file:   ./lvplot/vp_raster.c
  1648. X *
  1649. X * Joe Dellinger (SEP), June 11 1987
  1650. X *    Inserted this sample edit history entry.
  1651. X *    Please log any further modifications made to this file:
  1652. X * Joe Dellinger Jan 14 1988
  1653. X *    Do rounding.
  1654. X */
  1655. X
  1656. X/* This program cannot be indented! */
  1657. X
  1658. X#include <stdio.h>
  1659. X#include <vplot.h>
  1660. X#include "round.h"
  1661. X#include "vp_pc.h"
  1662. X
  1663. X#ifdef FORTRAN
  1664. X
  1665. X#define RASTER        vpraster_
  1666. X#define XLL        *xll
  1667. X#define YLL        *yll
  1668. X#define XPIX        *xpix
  1669. X#define YPIX        *ypix
  1670. X#define PPI        *ppi
  1671. X#define    BIT        *bit
  1672. X#define OFFSET        *offset
  1673. X#define    BLAST        *blast
  1674. X#define    ORIENT        *orient
  1675. X#define    INVERT        *invert
  1676. X
  1677. X#else
  1678. X
  1679. X#define RASTER        vp_raster
  1680. X#define XLL        xll
  1681. X#define YLL        yll
  1682. X#define XPIX        xpix
  1683. X#define YPIX        ypix
  1684. X#define PPI        ppi
  1685. X#define    BIT        bit
  1686. X#define OFFSET        offset
  1687. X#define    BLAST        blast
  1688. X#define    ORIENT        orient
  1689. X#define    INVERT        invert
  1690. X
  1691. X#endif
  1692. X
  1693. X#define ARRAY(A,B)    array[(((INVERT)==0)?(A):(YPIX-1-(A)))*(XPIX)+(B)]
  1694. X
  1695. X#define MAXREP    8
  1696. X#define PUTHSIZE sizeof(int)
  1697. X
  1698. X#define RASOUT(NUMPAT,NUMBYTE,BITFLAG,BYTES)    \
  1699. X{\
  1700. X    puth ((int) (NUMPAT), vp_pc._pltout);\
  1701. X    puth ((int) (NUMBYTE), vp_pc._pltout);\
  1702. X\
  1703. X    if (BITFLAG)\
  1704. X    {\
  1705. X    for (nn = 0; nn + 7 < (NUMBYTE); nn += 8)\
  1706. X    {\
  1707. X        obyte = 0x00;\
  1708. X\
  1709. X        obyte =\
  1710. X        ((*((BYTES) + nn + 0) != 0) << 7) |\
  1711. X        ((*((BYTES) + nn + 1) != 0) << 6) |\
  1712. X        ((*((BYTES) + nn + 2) != 0) << 5) |\
  1713. X        ((*((BYTES) + nn + 3) != 0) << 4) |\
  1714. X        ((*((BYTES) + nn + 4) != 0) << 3) |\
  1715. X        ((*((BYTES) + nn + 5) != 0) << 2) |\
  1716. X        ((*((BYTES) + nn + 6) != 0) << 1) |\
  1717. X        ((*((BYTES) + nn + 7) != 0) << 0);\
  1718. X        putc ((char) obyte, vp_pc._pltout);\
  1719. X    }\
  1720. X    if (nn < (NUMBYTE))\
  1721. X    {\
  1722. X        obyte = 0x00;\
  1723. X        for (nnn = 7; nn < (NUMBYTE); nn++, nnn--)\
  1724. X        {\
  1725. X        obyte |= ((*((BYTES) + nn) != 0) << nnn);\
  1726. X        }\
  1727. X        putc ((char) obyte, vp_pc._pltout);\
  1728. X    }\
  1729. X    }\
  1730. X    else\
  1731. X    {\
  1732. X    for (nn = 0; nn < (NUMBYTE); nn++)\
  1733. X    {\
  1734. X        putc ((char) * ((BYTES) + nn), vp_pc._pltout);\
  1735. X    }\
  1736. X    }\
  1737. X}
  1738. X
  1739. RASTER (array, blast, bit, offset, xpix, ypix, xll, yll, ppi, xur, yur, orient, invert)
  1740. unsigned char  *array;
  1741. float   XLL, YLL, *xur, *yur, PPI;
  1742. int     XPIX, YPIX, BIT, OFFSET, BLAST, ORIENT, INVERT;
  1743. X{
  1744. X    int     mm, nn, nnn, ll, kk, jj, ii, count, ucount, bitbyte;
  1745. X    int     ix, iy;
  1746. X    unsigned char   obyte;
  1747. X
  1748. X    if (BIT)
  1749. X    {
  1750. X    bitbyte = 8;
  1751. X    putc (VP_BIT_RASTER, vp_pc._pltout);
  1752. X    }
  1753. X    else
  1754. X    {
  1755. X    bitbyte = 1;
  1756. X    putc (VP_BYTE_RASTER, vp_pc._pltout);
  1757. X    }
  1758. X
  1759. X    if (ORIENT >= 0)
  1760. X    ORIENT = ORIENT % 4;
  1761. X    else
  1762. X    ORIENT = ((ORIENT % 4) + 4) % 4;
  1763. X
  1764. X    puth ((int) ORIENT, vp_pc._pltout);
  1765. X    puth ((int) offset, vp_pc._pltout);
  1766. X    ix = ROUND (XLL * RPERIN);
  1767. X    iy = ROUND (YLL * RPERIN);
  1768. X    puth (ix, vp_pc._pltout);
  1769. X    puth (iy, vp_pc._pltout);
  1770. X    if (PPI > 0)
  1771. X    {
  1772. X    ix += ROUND (RPERIN * XPIX / PPI);
  1773. X    iy += ROUND (RPERIN * YPIX / PPI);
  1774. X    *xur = ix / (float) RPERIN;
  1775. X    *yur = iy / (float) RPERIN;
  1776. X    }
  1777. X    else
  1778. X    {
  1779. X    ix = ROUND (*xur * RPERIN);
  1780. X    iy = ROUND (*yur * RPERIN);
  1781. X    }
  1782. X    puth (ix, vp_pc._pltout);
  1783. X    puth (iy, vp_pc._pltout);
  1784. X
  1785. X    puth ((int) XPIX, vp_pc._pltout);
  1786. X    puth ((int) YPIX, vp_pc._pltout);
  1787. X
  1788. X    if (BLAST)
  1789. X    {
  1790. X/* Don't try to compact it at all */
  1791. X    for (ii = 0; ii < YPIX; ii++)
  1792. X    {
  1793. X        puth ((int) 1, vp_pc._pltout);
  1794. X        RASOUT (1, XPIX, BIT, &ARRAY (ii, 0));
  1795. X    }
  1796. X    }
  1797. X    else
  1798. X    {
  1799. X/* Try to compact it */
  1800. X    count = 1;
  1801. X    for (ii = 0; ii < YPIX; ii++)
  1802. X    {
  1803. X        for (jj = 0; jj < XPIX; jj++)
  1804. X        {
  1805. X        if (ii == YPIX - 1 || ARRAY (ii, jj) != ARRAY (ii + 1, jj))
  1806. X        {
  1807. X/* Write this row out, it's not just a repeat of the next one */
  1808. X
  1809. X/* Write out how many times this line is to be repeated */
  1810. X            puth (count, vp_pc._pltout);
  1811. X
  1812. X/*
  1813. X * This entire section tries to efficiently represent ONE RASTER LINE
  1814. X */
  1815. X
  1816. X/*
  1817. X * Keep track of "unaccounted for" bytes between
  1818. X * bytes containted in a pattern
  1819. X */
  1820. X            ucount = 0;
  1821. X/* Loop through a raster line */
  1822. X            for (kk = 0; kk < XPIX; kk++)
  1823. X            {
  1824. X/* Try different size patterns */
  1825. X            for (ll = 1; ll <= MAXREP; ll++)
  1826. X            {
  1827. X/* See how far this pattern size works */
  1828. X                for (mm = 0; mm <= XPIX - (kk + ll); mm++)
  1829. X                {
  1830. X/* Pattern stopped working */
  1831. X                if (mm == XPIX - (kk + ll) ||
  1832. X                    ARRAY (ii, kk + mm) != ARRAY (ii, kk + mm + ll))
  1833. X                {
  1834. X/* See how many repetitions we got */
  1835. X                    mm = ll * (1 + (int) (mm / ll));
  1836. X/* Is it worth it to use this? */
  1837. X/* (PUTHSIZE is the number of bytes needed for a puth */
  1838. X                    if (PUTHSIZE * 2 + ll <= 1 + (mm - 1) / bitbyte)
  1839. X                    {
  1840. X/* First take care of bytes not in a pattern */
  1841. X                    if (ucount > 0)
  1842. X                    {
  1843. X                        RASOUT (1, ucount, BIT, &ARRAY (ii, kk - ucount));
  1844. X                        ucount = 0;
  1845. X                    }
  1846. X/* Now take care of the bytes in the pattern */
  1847. X                    RASOUT ((int) mm / ll, ll, BIT, &ARRAY (ii, kk));
  1848. X                    kk += mm - 1;
  1849. X/* Stop looking, we already found what we wanted */
  1850. X                    goto compact_found;
  1851. X                    }
  1852. X/* This pattern didn't work. Stop looking at this size and try a longer one */
  1853. X                    break;
  1854. X                }
  1855. X                }
  1856. X            }
  1857. X/* No pattern including this byte, add it to the unaccounted for list */
  1858. X            ucount++;
  1859. X        compact_found: 
  1860. X            continue;
  1861. X            }
  1862. X/* Take care of any bytes left hanging on the end */
  1863. X            if (ucount > 0)
  1864. X            {
  1865. X            RASOUT (1, ucount, BIT, &ARRAY (ii, kk - ucount));
  1866. X            }
  1867. X/*
  1868. X * END of section that does ONE RASTER LINE
  1869. X */
  1870. X
  1871. X
  1872. X/* Reset counter */
  1873. X            count = 1;
  1874. X/* Exit the loop */
  1875. X            break;
  1876. X        }
  1877. X        }
  1878. X/* If we didn't write it out, it will just be a repeat of the next one */
  1879. X        if (jj == XPIX)
  1880. X        count++;
  1881. X    }
  1882. X    }
  1883. X}
  1884. END_OF_FILE
  1885. if test 5777 -ne `wc -c <'Vplot_Kernel/lvplot/vp_raster.c'`; then
  1886.     echo shar: \"'Vplot_Kernel/lvplot/vp_raster.c'\" unpacked with wrong size!
  1887. fi
  1888. # end of 'Vplot_Kernel/lvplot/vp_raster.c'
  1889. fi
  1890. echo shar: End of archive 13 \(of 24\).
  1891. cp /dev/null ark13isdone
  1892. MISSING=""
  1893. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ; do
  1894.     if test ! -f ark${I}isdone ; then
  1895.     MISSING="${MISSING} ${I}"
  1896.     fi
  1897. done
  1898. if test "${MISSING}" = "" ; then
  1899.     echo You have unpacked all 24 archives.
  1900.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1901. else
  1902.     echo You still need to unpack the following archives:
  1903.     echo "        " ${MISSING}
  1904. fi
  1905. ##  End of shell archive.
  1906. exit 0
  1907.