home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / misc / volume02 / image < prev    next >
Encoding:
Internet Message Format  |  1991-08-27  |  58.0 KB
  1. From mipos3!intelca!oliveb!ames!necntc!ncoast!allbery Fri Jan 29 08:03:34 PST 1988
  2. Article 266 of comp.sources.misc:
  3. Path: td2cad!mipos3!intelca!oliveb!ames!necntc!ncoast!allbery
  4. From: everson@compsci.bristol.ac.uk (Phill Everson)
  5. Newsgroups: comp.sources.misc
  6. Subject: v02i019: Image processing programs
  7. Message-ID: <7130@ncoast.UUCP>
  8. Date: 26 Jan 88 04:07:33 GMT
  9. Sender: allbery@ncoast.UUCP
  10. Organization: Dept of Computer Science, University of Bristol, UK.
  11. Lines: 2834
  12. Approved: allbery@ncoast.UUCP
  13. X-Archive: comp.sources.misc/8801/19
  14. Comp.sources.misc: Volume 2, Issue 19
  15. Submitted-By: Phill Everson <everson@compsci.bristol.ac.uk>
  16. Archive-Name: image
  17.  
  18. Comp.sources.misc: Volume 2, Issue 19
  19. Submitted-By: Phill Everson <everson@compsci.bristol.ac.uk>
  20. Archive-Name: image
  21.  
  22. # To unbundle, sh this file
  23.  echo README 1>&2
  24. cat >README <<'End of README'
  25. In response to a plea on the net:
  26.  
  27. This is a family of image processing programs written by
  28. Phill Everson <everson@uk.aucc.bristol.cs: JANET
  29.                everson%uk.aucc.bristol.cs@nss.cs.ucl.ac.uk: ARPA ? >
  30. with help from Gareth Waddell (notably for the dynamic array library)
  31. at Bristol University in the UK for SUN workstations, both colour and 
  32. black/white.  It includes tools to display images on Colour monitors, 
  33. B/W monitors, to convolve a filter over an image, to create a histogram 
  34. of the greylevels in an image, to normalise an image, to threshold an image, 
  35. to convert an image to Postscript and ... (read the manual page alv(1) 
  36. for other features).
  37.  
  38. Alv stands for Autonomous Land Vehicle, the research project that these
  39. were originally developed for. Some of the tools have been used MUCH
  40. more than others and so can be regarded as being pretty much correct
  41. (dsp, cdsp, convolve, pixval, imagelw, subarea, subsample, coltable, hist
  42. & invert).
  43. If any of the others seem to be playing up it is possible that 
  44. there is a bug in there somewhere -- some tools were added at the 
  45. request of others who promised to test them and have never been heard 
  46. of since! Please send me any bug reports (&fixes?) to me.
  47.  
  48. *************************************************************************
  49. To get this system up and on the road:
  50.  
  51.     1. Edit the Makefile, changing the directory paths for
  52.        BINDIR, LIBDIR, INCDIR, MANDIR & FILDIR to suit your system.
  53.     2. Type 'make' and everything will be compiled and installed.
  54.     3. Read the manual page alv(1). It can be formatted from this 
  55.        directory by typing 'nroff -man alv.1 | more'.
  56. *************************************************************************
  57.  
  58. This family of programs has 3 manual pages; alv(1), alv(3) & alv(5).
  59. alv(1) has a general description of each of the programs and what each 
  60. of them should do. alv(3) is a description of the library created 
  61. and alv(5) is a description of the file format used for an image.
  62. (I've also included the manual page dynamem(3) for a dynamic memory 
  63. allocation library which is used by the alv library and which someone may 
  64. find useful.)
  65.  
  66. The method that we have found works best is that everyone working
  67. on vision-type programs uses the same file format (see alv(5)) and
  68. most people will use the core tools to display images etc and the
  69. library functions for their own programs.
  70.  
  71. These are and will be used a lot here, so if anybody adds or modifies them,
  72. please send me details and I'll collect, collate and possibly post notable 
  73. additions at a later date. Thanks.
  74.  
  75. I hope they're of some use.
  76.  
  77.                 Phill Everson
  78. End of README
  79.  echo Makefile 1>&2
  80. cat >Makefile <<'End of Makefile'
  81. #
  82. # ALV image processing programs
  83. # written by Phill Everson
  84. #            Computer Science Dept.
  85. #            Bristol University UK
  86. #            21st January, 1988
  87. #
  88. # <everson@uk.aucc.bristol.cs: JANET
  89. #  everson%uk.aucc.bristol.cs@nss.cs.ucl.ac.uk: ARPA ? >
  90. #
  91.  
  92. # BINDIR - location of compiled binaries
  93. # LIBDIR - location of compiled libraries
  94. # INCDIR - location of include files
  95. # MANDIR - location of top level of manual
  96. # FILDIR - location of filters (for convolve)
  97.  
  98. BINDIR = /usr/kukini/alv/vision/bin
  99. LIBDIR = /usr/kukini/alv/vision/lib
  100. INCDIR = /usr/kukini/alv/vision/include
  101. MANDIR = /usr/kukini/alv/vision/man
  102. FILDIR = /usr/kukini/alv/vision/usr/filters
  103. CFLAGS = -g -I$(INCDIR) 
  104.    ARC = vision.a
  105.  DLIBS = -lsuntool -lsunwindow -lpixrect -L$(LIBDIR) -lalv
  106.  OLIBS = -L$(LIBDIR) -lalv
  107.  PROGS = cdsp dsp convert addhead hist imagelw invert pixval retitle \
  108.          subarea subsample thresh normalise ffill convolve range striphead 
  109.  
  110. install: setup all docs filters
  111.     mv $(PROGS) $(BINDIR)
  112.  
  113. setup:
  114.     cp image.h $(INCDIR)
  115.  
  116. all: lib cdsp dsp convert addhead hist imagelw invert pixval retitle \
  117.      subarea subsample thresh normalise ffill convolve range striphead
  118.  
  119. filters: 
  120.     @cp avg1 lap1 sobel1 xdiff1 $(FILDIR)
  121.  
  122. archive: clean
  123.     @ar crv $(ARC) *
  124.     @compress $(ARC)
  125.     @mv $(ARC).Z $(ARCHIVE_DIR)
  126.     
  127. docs:
  128.     @cp alv.1 $(MANDIR)/man1
  129.     @cp alv.3 $(MANDIR)/man3
  130.     @cp alv.5 $(MANDIR)/man5
  131.     @cp dynamem.3 $(MANDIR)/man3
  132.  
  133. cdsp: cdsp.o 
  134.     cc $(CFLAGS) cdsp.o -o cdsp $(DLIBS)
  135.  
  136. dsp: dsp.o
  137.     cc $(CFLAGS) dsp.o -o dsp $(DLIBS)
  138.  
  139. hist: hist.o
  140.     cc $(CFLAGS) hist.o -o hist $(DLIBS) -lm
  141.  
  142. convert: convert.o
  143.     cc $(CFLAGS) convert.o -o convert -L$(LIBDIR) -ldynamem
  144.  
  145. addhead: addhead.o
  146.     cc $(CFLAGS) addhead.o -o addhead -L$(LIBDIR) -ldynamem
  147.  
  148. striphead: striphead.o
  149.     cc $(CFLAGS) striphead.o -o striphead $(OLIBS)
  150.  
  151. convolve.o: convolve.c
  152.     cc $(CFLAGS) -DFILTERS_DIR=$(FILDIR) -c convolve.c
  153.  
  154. convolve: convolve.o
  155.     cc $(CFLAGS) convolve.o -o convolve $(OLIBS)
  156.  
  157. invert: invert.o
  158.     cc $(CFLAGS) invert.o -o invert $(OLIBS)
  159.  
  160. pixval: pixval.o
  161.     cc $(CFLAGS) pixval.o -o pixval $(OLIBS)
  162.  
  163. retitle: retitle.o
  164.     cc $(CFLAGS) retitle.o -o retitle $(OLIBS)
  165.  
  166. range: range.o
  167.     cc $(CFLAGS) range.o -o range $(OLIBS)
  168.  
  169. imagelw: imagelw.o
  170.     cc $(CFLAGS) imagelw.o -o imagelw $(OLIBS)
  171.  
  172. subsample: subsample.o
  173.     cc $(CFLAGS) subsample.o -o subsample $(OLIBS)
  174.  
  175. subarea: subarea.o
  176.     cc $(CFLAGS) subarea.o -o subarea $(OLIBS)
  177.  
  178. thresh: thresh.o
  179.     cc $(CFLAGS) thresh.o -o thresh $(OLIBS) -lm
  180.  
  181. normalise: normalise.o
  182.     cc $(CFLAGS) normalise.o -o normalise $(OLIBS)
  183.  
  184. ffill: ffill.o
  185.     cc $(CFLAGS) ffill.o -o ffill $(OLIBS)
  186.  
  187. lib: alvlib.o dynamem.o
  188.     ar rc libalv.a alvlib.o dynamem.o
  189.     ranlib libalv.a
  190.     ar rc libdynamem.a dynamem.o
  191.     ranlib libdynamem.a
  192.     mv libalv.a libdynamem.a $(LIBDIR)
  193.     touch lib
  194.     
  195. wc: 
  196.     @wc *.c | sort -n
  197.  
  198. clean:
  199.     @touch dummy.o
  200.     @/bin/rm *.o
  201.  
  202. troff:
  203.     troff -t -man alv.1 | thack | pspr
  204.     troff -t -man alv.3 | thack | pspr
  205.     troff -t -man alv.5 | thack | pspr
  206. End of Makefile
  207.  echo addhead.c 1>&2
  208. cat >addhead.c <<'End of addhead.c'
  209. #include <stdio.h>
  210.  
  211. main(argc,argv)
  212. int argc;
  213. char **argv;
  214. {
  215.     int i,j;
  216.     int xsize,ysize;
  217.     unsigned char **pic;
  218.     char *file, *title;
  219.     FILE *fp;
  220.  
  221.     if (argc!=5) {
  222.         fprintf(stderr,"Usage: %s: x y filename title\n",argv[0]);
  223.         exit(-1);
  224.         }
  225.  
  226.     xsize=atoi(argv[1]);
  227.     ysize=atoi(argv[2]);
  228.     file =argv[3];
  229.     title =argv[4];
  230.  
  231.     if (!(fp=fopen(file,"r"))) {
  232.         fprintf(stderr,"Cannot open %s\n",file);
  233.         exit(-1);
  234.         }
  235.  
  236.     pic = (unsigned char **) dynamem (&pic, sizeof(unsigned char), 2, ysize, xsize);
  237.  
  238.     putw(xsize<<16|ysize,stdout);
  239.  
  240.     for (i=0;i<252;i++,*title?title++:0)
  241.         putchar(*title?*title:0);
  242.     
  243.     for (j=0;j<ysize;j++)
  244.         for (i=0;i<xsize;i++)
  245.             pic[j][i]=getc(fp);
  246.  
  247.     for (j=0;j<ysize;j++)
  248.         for(i=0;i<xsize;i++)
  249.             putchar(pic[j][i]);
  250.     
  251.     fclose(fp);
  252. }
  253. End of addhead.c
  254.  echo alv.1 1>&2
  255. cat >alv.1 <<'End of alv.1'
  256. .\" .TH name section cent-foot
  257. .TH ALV 1 "4th December 1987"
  258. .SH NAME
  259. .\" name \- function
  260. alv \- standard ALV tools
  261. .SH SYNOPSIS
  262. .\" Bold keywords, Italic variables, [] options, | alternatives.
  263. wind_opts = [
  264. .BI -X n
  265. ] [
  266. .BI -Y n
  267. ] [
  268. .BI -x n
  269. ] [
  270. .BI -y n
  271. ]
  272. .br
  273. std_opts = 
  274. .RB [ -H ]
  275. [
  276. .BI -T title
  277. ]
  278. .RI [ filename ]
  279. .br
  280. .B dsp
  281. .RB [ -m ]
  282. .RB [ wind_opts ]
  283. .RB [ std_opts ]
  284. .br
  285. .B cdsp
  286. .RB [ -m ]
  287. .RB [ wind_opts ]
  288. .RB [ std_opts ]
  289. .br
  290. .B imagelw
  291. .RB [ wind_opts ]
  292. .RB [ std_opts ]
  293. .RB [ -t ]
  294. .RB [ -m ]
  295. .RB [ -c ]
  296. .RB [ - ]
  297. .br
  298. .B hist
  299. .RB [ -l ]
  300. .RB [ -v ]
  301. .RB [ wind_opts ]
  302. .RB [ std_opts ]
  303. .br
  304. .B thresh
  305. [
  306. .BI -t n
  307. ]
  308. .RB [ std_opts ]
  309. .br
  310. .B invert
  311. .RB [ std_opts ]
  312. .br
  313. .B normalise
  314. .RB [ std_opts ]
  315. .br
  316. .B range
  317. [
  318. .BI -l n
  319. ]
  320. [
  321. .BI -h n
  322. ]
  323. .RB [ std_opts ]
  324. .br
  325. .B convolve
  326. [
  327. .BI -f filtername
  328. ]
  329. .RB [ -e ]
  330. .RB [ -F ]
  331. .RB [ std_opts ]
  332. .br
  333. .B subsample
  334. .I xsize
  335. .I ysize
  336. .RB [ std_opts ]
  337. .br
  338. .B subarea
  339. [
  340. .BI -x n
  341. ]
  342. [
  343. .BI -y n
  344. ]
  345. [
  346. .BI -X n
  347. ]
  348. [
  349. .BI -Y n
  350. ]
  351. .RB [ std_opts ]
  352. .br
  353. .B pixval
  354. [
  355. .BI -x n
  356. ]
  357. [
  358. .BI -y n
  359. ]
  360. [
  361. .BI -X n
  362. ]
  363. [
  364. .BI -Y n
  365. ]
  366. .RB [ std_opts ]
  367. .br
  368. .B ffill
  369. .I "xpos ypos"
  370. [ 
  371. .BI -b n 
  372. ]
  373. .RB [ std_opts ]
  374. .br
  375. .B retitle
  376. .RB [ std_opts ]
  377. .br
  378. .B convert
  379. .I xsize
  380. .I ysize
  381. .I filename
  382. .I title
  383. .br
  384. .B addhead
  385. .I xsize
  386. .I ysize
  387. .I filename
  388. .I title
  389. .br
  390. .B striphead
  391. .RB [ std_opts ]
  392. .br
  393.  
  394. .SH DESCRIPTION
  395. .\" Italic files, commands, IR manual-entry (manual-section)
  396. These tools comprise
  397. the majority of those
  398. needed for work on the
  399. .I ALV
  400. and
  401. .I Bubble
  402. projects.
  403. They use a standard
  404. file format, see 
  405. .IR alv (5).
  406. .I Dsp
  407. and
  408. .I cdsp
  409. display pictures
  410. on a monochrome
  411. and colour display
  412. respectively. (Place the mouse in the window
  413. created by 
  414. .I coltable 
  415. on a Colour Sun to see
  416. the image in false colour).
  417. .I Imagelw
  418. displays the picture on the
  419. Apple Laserwriter in
  420. The Sun Lounge.
  421. .I Hist
  422. displays histogram
  423. displays, either
  424. linearly or logorithmically.
  425. .I Thresh
  426. thresholds data on a
  427. picture using either
  428. a specified threshold
  429. value or an automatically
  430. generated one.
  431. .I Invert
  432. inverts all the data in
  433. an image.
  434. .I Normalise
  435. normalises the histogram
  436. of an image.
  437. .I Range 
  438. stretches the grey level distribution
  439. of an image.
  440. .I Convolve
  441. performs a convolution
  442. on an image using 
  443. a specified filter.
  444. .I Subsample
  445. reduces the picture
  446. size by subsampling
  447. the original picture
  448. (but can also be used
  449. to enlarge).
  450. .I Subarea
  451. creates a new picture
  452. which is a part of the
  453. original picture.
  454. .I Pixval
  455. enables a decimal valued
  456. print of an area of an
  457. image to be generated.
  458. .I Ffill
  459. flood fills an image based
  460. around a small point, with
  461. a specified boundary colour.
  462. .I Retitle
  463. gives a picture a new title.
  464. .I Convert
  465. converts a file stored in the old 
  466. alv file format to the new.
  467. .I Addhead
  468. adds a header, thus converting
  469. it to the standard file format, 
  470. to a file produced
  471. by, for example, the 
  472. .I "ALV Framegrabber."
  473. .I Striphead
  474. removes a header from an image.
  475. .SH OPTIONS
  476. .\" Itemised list of options
  477. .TP 4
  478. Window Options
  479. -Xn           window x size is n
  480. .br
  481. -Yn           window y size is n
  482. .br
  483. -xn           window x offset is n
  484. .br
  485. -yn           window y offset is n
  486. .br
  487. .TP 4
  488. Standard Options
  489. -H            give help list
  490. .br
  491. -Ttitle       output-image title
  492. .br
  493. filename      read from filename
  494. .br
  495. .TP 4
  496. Dsp/Cdsp Options
  497. -m            use backing pixrect
  498. .br
  499. .TP 4
  500. Imagelw Options
  501. -T            produce TeX special file
  502. .br
  503. -m            send mail on completion of print
  504. .br
  505. -c            automatically scale picture to fit page
  506. .br
  507. -             write Postscript program to standard output
  508. .br
  509. .TP 4
  510. Hist Options
  511. -l            logarithmic scaling
  512. .br
  513. -v            vertical lines off
  514. .br
  515. .TP 4
  516. Thresh Options
  517. -tn           threshold value
  518. .br
  519. .TP 4
  520. Normalise Options
  521. -ln           least normalise value
  522. .br
  523. -hn           highest normalise value
  524. .br
  525. .TP 4
  526. Convolve Options
  527. -ffiltername  use filter filtername
  528. .br
  529. -e            enhanced scaling
  530. .br
  531. -F            list all filters
  532. .br
  533. .TP 4
  534. Pixval Options
  535. -Xn           x size
  536. .br
  537. -Yn           y size
  538. .br
  539. -xn           x offset
  540. .br
  541. -yn           y offset
  542. .br
  543. .TP 4
  544. Ffill Options
  545. -bn           boundary grey level
  546. .br
  547. .\".SH FILES
  548. .\" List of all files used by the program
  549. .SH "SEE ALSO"
  550. .\" List of references, textual, and MAN pages.
  551. alv(3), alv(5).
  552. .\".SH DIAGNOSTICS
  553. .\" List of error messages and return codes the user may expect
  554. .SH BUGS
  555. .\" Known Limitations or Desirable additions to the command
  556. The code to pick out the filename from the command arguments 
  557. list is unreliable in some cases. (It will core dump). 
  558. This can be avoided by using cat to pipe the file into the
  559. command.
  560. End of alv.1
  561.  echo alv.3 1>&2
  562. cat >alv.3 <<'End of alv.3'
  563. .\" .TH name section cent-foot left-foot cent-head
  564. .TH ALV 3 "4th December 1987"
  565. .SH NAME
  566. .\" name \- function
  567. alv \- standard library functions
  568. .SH SYNOPSIS
  569. .\" Bold keywords, Italic variables, [] options, | alternatives.
  570. typedef struct img {
  571. .br
  572.     unsigned char **image;
  573. .br
  574.     short xsize, ysize;
  575. .br
  576.     char title[252];
  577. .br
  578. } IMAGE;
  579. .sp
  580. int winxsize, winysize,
  581. .br
  582.     winxoff,  winyoff;
  583. .br
  584. int helpflag;
  585. .br
  586. char *newtitle;
  587. .sp
  588. IMAGE *readimage(fp)
  589. .br
  590. FILE *fp;
  591. .sp
  592. writeimage(fp,image)
  593. .br
  594. FILE *fp;
  595. .br
  596. IMAGE *image;
  597. .sp
  598. IMAGE *newimage(xsize,ysize,title)
  599. .br
  600. int xsize,ysize;
  601. .br
  602. char *title
  603. .sp
  604. subsample(image1,image2)
  605. .br
  606. IMAGE *image1,*image2;
  607. .sp
  608. subarea(image1,image2,xoff,yoff)
  609. .br
  610. IMAGE *image1,*image2;
  611. .br
  612. int xoff,yoff;
  613. .sp
  614. stdopts(argc,argv)
  615. .br
  616. int *argc;
  617. .br
  618. char **argv;
  619. .sp
  620. windopts(argc,argv)
  621. .br
  622. int *argc;
  623. .br
  624. char **argv;
  625. .SH DESCRIPTION
  626. .\" Italic files, commands, IR manual-entry (manual-section)
  627. .I Readin
  628. reads in an image from
  629. the specified file, and
  630. creates an image structure
  631. with all the relevant
  632. data contained in it.
  633. .I Writeout
  634. writes the specified
  635. image to the specified
  636. file.
  637. .I Newimage
  638. creates a new
  639. image of the specified
  640. dimensions.
  641. .I Subsample
  642. reproduces the whole
  643. of
  644. .I image1
  645. in
  646. .I image2
  647. suitably scaled (up or
  648. down) so as to make
  649. it fit into the available
  650. room in
  651. .IR image2 .
  652. .I Subarea
  653. reproduces the relevant
  654. part of
  655. .I image1
  656. in
  657. .I image2
  658. so that
  659. .I image2
  660. has the same resolution as
  661. .I image1
  662. and is as full as possible
  663. (note that it is possible
  664. to use this also to increase
  665. the size of an image).
  666. .I Stdopts
  667. parses the
  668. .B -t
  669. and
  670. .B -h options
  671. setting
  672. .I helpflag
  673. and
  674. .IR newtitle .
  675. .I Windopts
  676. parses the
  677. .BR -x , -y , -X ,
  678. .B -Y
  679. options setting
  680. the variables
  681. .IR winxsize , winysize , winxoff ,
  682. .IR winyoff .
  683. .\".SH FILES
  684. .\" List of all files used by the program
  685. .SH "SEE ALSO"
  686. .\" List of references, textual, and MAN pages.
  687. alv(1),alv(3).
  688. .\".SH DIAGNOSTICS
  689. .\" List of error messages and return codes the user may expect
  690. .\".SH BUGS
  691. .\" Known Limitations or Desirable additions to the command
  692. End of alv.3
  693.  echo alv.5 1>&2
  694. cat >alv.5 <<'End of alv.5'
  695. .\" .TH name section cent-foot left-foot cent-head
  696. .TH ALV 5 "4th December 1987"
  697. .SH NAME
  698. .\" name \- function
  699. alv \- common file format
  700. .SH SYNOPSIS
  701. .\" Bold keywords, Italic variables, [] options, | alternatives.
  702. typedef struct img {
  703. .br
  704.     unsigned char **image;
  705. .br
  706.     short xsize, ysize;
  707. .br
  708.     char title[252];
  709. .br
  710. } IMAGE;
  711. .SH DESCRIPTION
  712. .\" Italic files, commands, IR manual-entry (manual-section)
  713. This is the newly approved
  714. "standard" file format for 
  715. image processing work
  716. done by the
  717. .I alv
  718. group at Bristol University.
  719. The file consists of a 256-byte
  720. header followed by
  721. .I ysize
  722. rows each
  723. .I xsize
  724. in length.
  725. The header consists of a
  726. two-byte value for
  727. .IR xsize ,
  728. a two-byte value for
  729. .IR ysize ,
  730. and a 252-byte title,
  731. which may be interpreted
  732. as appropriate by any tool.
  733. .\".SH OPTIONS
  734. .\" Itemised list of options
  735. .\".SH FILES
  736. .\" List of all files used by the program
  737. .SH "SEE ALSO"
  738. .\" List of references, textual, and MAN pages.
  739. alv(1),alv(3)
  740. .\".SH DIAGNOSTICS
  741. .\" List of error messages and return codes the user may expect
  742. .\".SH BUGS
  743. .\" Known Limitations or Desirable additions to the command
  744. End of alv.5
  745.  echo alvlib.c 1>&2
  746. cat >alvlib.c <<'End of alvlib.c'
  747. #include <stdio.h> 
  748. #include "image.h" 
  749.  
  750. int winxsize=0,winysize=0,
  751.     winxoff=0, winyoff=0;
  752. int helpflag;
  753. char *newtitle=0;
  754.  
  755. IMAGE *readimage(fp)
  756. FILE *fp;
  757. {
  758.     int i, j, xsize, ysize;
  759.     char title[252];
  760.     IMAGE *img, *newimage();
  761.  
  762.     i=getw(fp);
  763.  
  764.     for(j=0;j<252;j++)
  765.         title[j]=getc(fp);
  766.  
  767.     img = newimage(xsize=(i>>16),ysize=(i&65535),title);
  768.  
  769.     for(j=0;j<ysize;j++)
  770.         for(i=0;i<xsize;i++)
  771.             (img->image[j][i])=getc(fp);     /* UGH! */
  772.  
  773.     return img;
  774. }
  775.  
  776. writeimage(fp,image)
  777. FILE *fp;
  778. IMAGE *image;
  779. {
  780.     int i,j;
  781.  
  782.     putw(image->xsize<<16|image->ysize,fp);
  783.  
  784.     for(j=0;j<252;j++)
  785.         putc(image->title[j],fp);
  786.  
  787.     for(j=0;j<image->ysize;j++)
  788.         for(i=0;i<image->xsize;i++)
  789.             putc(image->image[j][i],fp);
  790.  
  791. }
  792.  
  793. IMAGE *newimage(xsize,ysize,title)
  794. int xsize,ysize;
  795. char *title;
  796. {
  797. IMAGE *img;
  798. int i;
  799.  
  800.     if ((img=(IMAGE *)malloc(sizeof(IMAGE)))==NULL)
  801.         return 0;
  802.     if ((img->image = (unsigned char **) dynamem (&(img->image), sizeof(unsigned char), 2, ysize, xsize))==NULL)
  803.         return 0;
  804.     img->xsize=xsize;
  805.     img->ysize=ysize;
  806.     for (i=0;i<252;i++)
  807.         img->title[i]=0;
  808.     strcpy(img->title,title);
  809.     return img;
  810. }
  811.  
  812. subsample(image1,image2)
  813. IMAGE *image1,*image2;
  814. {
  815. int cvx,cvy,lcx,lcy,hcx,hcy;
  816. register int i,j,i1,j1;
  817. int total;
  818.  
  819.     cvx=(100*image1->xsize)/image2->xsize;
  820.     cvy=(100*image1->ysize)/image2->ysize;
  821.  
  822.     for (j=0;j<image2->ysize;j++)
  823.         for (i=0;i<image2->xsize;i++)
  824.         {
  825.             hcx=i*cvx/100;
  826.             hcy=j*cvy/100;
  827.             lcx=(i-1)*cvx/100+1;
  828.             lcy=(j-1)*cvy/100+1;
  829.             lcx=(lcx<0)?0:(lcx>hcx)?hcx:lcx;
  830.             lcy=(lcy<0)?0:(lcy>hcy)?hcy:lcy;
  831.  
  832.             total=0;
  833.             for (j1=lcy;j1<=hcy;j1++)
  834.                 for (i1=lcx;i1<=hcx;i1++)
  835.                     total+=image1->image[j1][i1];
  836.             image2->image[j][i]=total/((hcx+1-lcx)*(hcy+1-lcy));
  837.         }
  838. }
  839.  
  840. subarea(image1,image2,xoff,yoff)
  841. IMAGE *image1,*image2;
  842. int xoff,yoff;
  843. {
  844. int xmin,ymin,
  845.     xmax,ymax;
  846. int i,j;
  847.  
  848.     xmin=(xoff<0)?0:xoff;
  849.     ymin=(yoff<0)?0:yoff;
  850.     xmax=image2->xsize+xoff;
  851.     ymax=image2->ysize+yoff;
  852.     xmax=(xmax>image1->xsize)?image1->xsize:xmax;
  853.     ymax=(ymax>image1->ysize)?image1->ysize:ymax;
  854.  
  855.     for (j=ymin;j<ymax;j++)
  856.         for (i=xmin;i<xmax;i++)
  857.             image2->image[j-yoff][i-xoff]=image1->image[j][i];
  858. }
  859.  
  860. stdopts(argc,argv)
  861. char **argv;
  862. int *argc;
  863. {
  864. int testflag;
  865. char **p;
  866.  
  867.     helpflag=0;
  868.     for (argv++;*argv;argv++)
  869.         if (**argv=='-') {
  870.             testflag=1;
  871.             switch ((*argv)[1]) {
  872.             case 'H': helpflag = 1;
  873.                       break;
  874.             case 'T': newtitle= *argv+2;
  875.                       break;
  876.             default:
  877.                 testflag=0;
  878.             }
  879.             if (testflag)
  880.             {
  881.                 for (p=argv;*p;p++)
  882.                     p[0] = p[1];
  883.                 (*argc)--;
  884.                 argv--;
  885.             }
  886.         }
  887. }
  888.  
  889. windopts(argc,argv)
  890. char **argv;
  891. int *argc;
  892. {
  893. int testflag;
  894. char **p;
  895.  
  896.     for (argv++;*argv;argv++)
  897.         if (**argv=='-') {
  898.             testflag=1;
  899.             switch ((*argv)[1]) {
  900.             case 'X': winxsize=atoi(*argv+2);
  901.                       break;
  902.             case 'Y': winysize=atoi(*argv+2);
  903.                       break;
  904.             case 'x': winxoff=atoi(*argv+2);
  905.                       break;
  906.             case 'y': winyoff=atoi(*argv+2);
  907.                       break;
  908.             default:
  909.                 testflag=0;
  910.             }
  911.             if (testflag)
  912.             {
  913.                 for (p=argv;*p;p++)
  914.                     p[0] = p[1];
  915.                 (*argc)--;
  916.                 argv--;
  917.             }
  918.         }
  919. }
  920. End of alvlib.c
  921.  echo avg1 1>&2
  922. cat >avg1 <<'End of avg1'
  923. 7 7
  924.  
  925. 1 1 1 1 1 1 1
  926. 1 1 1 1 1 1 1
  927. 1 1 1 1 1 1 1
  928. 1 1 1 1 1 1 1
  929. 1 1 1 1 1 1 1
  930. 1 1 1 1 1 1 1
  931. 1 1 1 1 1 1 1
  932. End of avg1
  933.  echo cdsp.c 1>&2
  934. cat >cdsp.c <<'End of cdsp.c'
  935. #include <suntool/sunview.h>
  936. #include <suntool/canvas.h>
  937. #include "image.h"
  938. #include <stdio.h>
  939.  
  940. int boxsize = 1, mflag = 0;
  941. static void getcoords();
  942. static void repaint_canvas();
  943. IMAGE *image;
  944.  
  945. main(argc, argv)
  946. int argc;
  947. char **argv;
  948.  
  949. {
  950.     Frame frame;
  951.     Canvas canvas;
  952.     Pixwin *pw;
  953.     Cursor cursor;
  954.     char cmsname[CMS_NAMESIZE];
  955.     u_char red[256], green[256], blue[256];
  956.     int i, j, x, y;
  957.     FILE *fp, *fopen();
  958.     u_char *pi;
  959.     char *imagefile=NULL;
  960.  
  961.     stdopts(&argc,argv);
  962.     windopts(&argc,argv);
  963.  
  964.     for (argv++;*argv;*argv++)
  965.         if (**argv=='-' && (*argv)[1]=='m') 
  966.             mflag = 1;
  967.         else imagefile= *argv;
  968.  
  969.     if (imagefile==NULL)
  970.         fp=stdin;
  971.     else if (!(fp = fopen(imagefile,"r"))) {
  972.         fprintf(stderr,"Cannot open %s\n",imagefile);
  973.         exit(-1);
  974.         }
  975.  
  976.     image = readimage(fp);
  977.  
  978.     /* Initialise variables used to set colour map segment */
  979.     for (i = 0; i < 256; i++) {
  980.         red[i] = i;
  981.         green[i] = i;
  982.         blue[i] = i;
  983.     }
  984.  
  985.     cursor = cursor_create(CURSOR_CROSSHAIR_COLOR, 255,
  986.                    CURSOR_SHOW_CURSOR, FALSE,
  987.                    CURSOR_SHOW_CROSSHAIRS, TRUE,
  988.                    CURSOR_CROSSHAIR_LENGTH, 20,
  989.                    CURSOR_CROSSHAIR_GAP, 5,
  990.                    0);
  991.  
  992.     /* create frame and canvas */
  993.     frame = window_create(NULL, FRAME,
  994.                   FRAME_LABEL, (newtitle)?newtitle:image->title,
  995.                   WIN_X, winxoff,
  996.                   WIN_Y, winyoff,
  997.                   WIN_HEIGHT, (winxsize)?winxsize:image->ysize * boxsize + 22,
  998.                   WIN_WIDTH, (winysize)?winysize:image->xsize * boxsize + 10,
  999.                   0);
  1000.  
  1001.     if (mflag)
  1002.         canvas = window_create(frame, CANVAS,
  1003.                        CANVAS_HEIGHT, image->ysize * boxsize,
  1004.                        CANVAS_WIDTH, image->xsize * boxsize,
  1005.                        WIN_CURSOR, cursor,
  1006.                        WIN_EVENT_PROC, getcoords,
  1007.                        0);
  1008.     else
  1009.         canvas = window_create(frame, CANVAS,
  1010.                        CANVAS_HEIGHT, image->ysize * boxsize,
  1011.                        CANVAS_WIDTH, image->xsize * boxsize,
  1012.                        WIN_CURSOR, cursor,
  1013.                        WIN_EVENT_PROC, getcoords,
  1014.                        CANVAS_RETAINED, FALSE,
  1015.                        CANVAS_REPAINT_PROC, repaint_canvas,
  1016.                        0);
  1017.  
  1018.     /* get the canvas pixwin to draw into */
  1019.     pw = canvas_pixwin(canvas);
  1020.  
  1021.     /* Set colour map segment */
  1022.     pw_setcmsname(pw, "grays");
  1023.     pw_putcolormap(pw, 0, 256, red, green, blue);
  1024.  
  1025.     if (mflag) {
  1026.         /* Enable batching for efficiency */
  1027.         pw_batch_on(pw);
  1028.  
  1029.         /* Draw gray boxes */
  1030.         pi = image->image[0];
  1031.         for (y = 0; y < image->ysize; y++)
  1032.             for (x = 0; x < image->xsize; x++) {
  1033.                 pw_put(pw, x, y, *pi);
  1034.                 pi++;
  1035.             }
  1036.         pw_batch_off(pw);
  1037.     }
  1038.  
  1039.     window_main_loop(frame);
  1040. }
  1041.  
  1042. static void
  1043. repaint_canvas(canvas, pw, repaint_area)
  1044. Canvas canvas;
  1045. Pixwin *pw;
  1046. Rectlist *repaint_area;
  1047. {
  1048.     u_char *pi;
  1049.     int x, y;
  1050.     int xstart, ystart, xstop, ystop;
  1051.  
  1052.     xstart = repaint_area->rl_bound.r_left / boxsize;
  1053.     ystart = repaint_area->rl_bound.r_top / boxsize;
  1054.     xstop = xstart + 1 + repaint_area->rl_bound.r_width / boxsize;
  1055.     ystop = ystart + 1 + repaint_area->rl_bound.r_height / boxsize;
  1056.  
  1057.     xstop = (xstop > image->xsize) ? image->xsize : xstop;
  1058.     ystop = (ystop > image->ysize) ? image->ysize : ystop;
  1059.  
  1060.     /* Enable locking for efficiency */
  1061.  
  1062.     /* Draw gray boxes */
  1063.     for (y = ystart; y < ystop; y++) {
  1064.         pi = &(image->image[y][xstart]);
  1065.         pw_lock(pw, &(repaint_area->rl_bound));
  1066.         for (x = xstart; x < xstop; x++) {
  1067.             /* Fill in a square box */
  1068.             pw_put(pw, x, y, *pi);
  1069.             pi++;
  1070.         }
  1071.         pw_unlock(pw);
  1072.     }
  1073. }
  1074.  
  1075. static void
  1076. getcoords(canvas, event, arg)
  1077. Canvas canvas;
  1078. Event *event;
  1079. caddr_t arg;
  1080. {
  1081.     if ((event_id(event) == MS_LEFT) && event_is_down(event)) {
  1082.         printf("%s: locator x,y : %d %d \n", (newtitle)?newtitle:image->title,
  1083.                event_x(event) / boxsize, event_y(event) / boxsize);
  1084.     }
  1085. }
  1086. End of cdsp.c
  1087.  echo coltable.c 1>&2
  1088. cat >coltable.c <<'End of coltable.c'
  1089. #include <suntool/sunview.h>
  1090. #include <suntool/canvas.h>
  1091. #include <stdio.h>
  1092. #include <math.h>
  1093.  
  1094. #define MINC 0
  1095.  
  1096. main(argc,argv)
  1097. int argc;
  1098. char ** argv;
  1099.  
  1100.    {
  1101.     Frame frame;
  1102.     Canvas canvas;
  1103.     Pixwin *pw;
  1104.     char cmsname[CMS_NAMESIZE];
  1105.     u_char red[256], green[256], blue[256];
  1106.     int i,ii,j,x,y;
  1107.     int delt,rem,region;
  1108.     int range ;
  1109.     float factor;
  1110.     char *tabname;
  1111.  
  1112.     range = 255 - MINC;
  1113.     delt = 43;
  1114.     factor = ((double)range)/(delt-1);
  1115.     tabname = (argv[0][0] == 'i') ? "icols" : "cols";
  1116.  
  1117.     /* Initialise variables used to set colour map segment */
  1118.     for (ii=0 ; ii<256 ; ii++)
  1119.     {
  1120.        i = (argv[0][0] == 'i') ? 255 - ii : ii ;
  1121.  
  1122.        region = ii/delt;
  1123.        rem = ii % delt;
  1124.  
  1125.        switch (region) {
  1126.  
  1127.        case 0 :
  1128.           red[i]   =  range +MINC ;
  1129.           green[i] =  range - rem* factor +MINC ;
  1130.           blue[i]  =  range - rem* factor +MINC;
  1131.           break;
  1132.  
  1133.        case 1 :
  1134.           red[i] = range +MINC;
  1135.           green[i] = rem * factor +MINC ;
  1136.           blue[i] = 0 +MINC ;
  1137.           break;
  1138.  
  1139.        case 2:
  1140.           red[i] = range - rem* factor +MINC ;
  1141.           green[i] = range +MINC ;
  1142.           blue[i] = 0 +MINC ;
  1143.           break;
  1144.  
  1145.        case 3:
  1146.           red[i] = 0 +MINC ;
  1147.           green[i] = range +MINC ;
  1148.           blue[i] = rem * factor +MINC ;
  1149.           break;
  1150.    
  1151.        case 4:
  1152.           red[i] = 0 +MINC ;
  1153.           green[i] = range - rem * factor +MINC ;
  1154.           blue[i] = range +MINC ;
  1155.           break;
  1156.  
  1157.        case 5:
  1158.        default:
  1159.           red[i] = rem * factor +MINC ;
  1160.           blue[i] = range +MINC ;
  1161.           green[i] = 0 +MINC ;
  1162.           break;
  1163.  
  1164.        } /* end switch */
  1165.  
  1166.     /* cludge to give more yellow etc */
  1167.     red[i] = sqrt((double)(red[i]-MINC))*sqrt((double)range) +MINC;
  1168.     blue[i] = sqrt((double)(blue[i]-MINC))*sqrt((double)range) +MINC;
  1169.     green[i] = sqrt((double)(green[i]-MINC))*sqrt((double)range) +MINC;
  1170.     }
  1171.  
  1172.     /* create frame and canvas */
  1173.     frame = window_create(NULL, FRAME,
  1174.     WIN_HEIGHT,    50,
  1175.     WIN_WIDTH,     100,
  1176.     0);
  1177.     canvas = window_create(frame,CANVAS, 0);
  1178.  
  1179.  
  1180.     /* get the cancas pixwin to draw into */
  1181.     pw = canvas_pixwin(canvas);
  1182.  
  1183.     /* Set colour map segment */
  1184.     pw_setcmsname(pw, tabname);
  1185.     pw_putcolormap(pw, 0, 256, red, green, blue);
  1186.  
  1187.     pw_batch_on(pw);
  1188.  
  1189.     window_main_loop(frame);
  1190.  
  1191.     exit(0);
  1192.    }
  1193. End of coltable.c
  1194.  echo convert.c 1>&2
  1195. cat >convert.c <<'End of convert.c'
  1196. #include <stdio.h>
  1197.  
  1198. main(argc,argv)
  1199. int argc;
  1200. char **argv;
  1201. {
  1202.     int i,j;
  1203.     int xsize,ysize;
  1204.     unsigned char **pic;
  1205.     char *file, *title;
  1206.     FILE *fp;
  1207.  
  1208.     if (argc!=5) {
  1209.         fprintf(stderr,"Usage: %s: x y filename title\n",argv[0]);
  1210.         exit(-1);
  1211.         }
  1212.  
  1213.     xsize=atoi(argv[1]);
  1214.     ysize=atoi(argv[2]);
  1215.     file =argv[3];
  1216.     title =argv[4];
  1217.  
  1218.     if (!(fp=fopen(file,"r"))) {
  1219.         fprintf(stderr,"Cannot open %s\n",file);
  1220.         exit(-1);
  1221.         }
  1222.  
  1223.     pic = (unsigned char **) dynamem (&pic, sizeof(unsigned char), 2, ysize, xsize);
  1224.  
  1225.     putw(xsize<<16|ysize,stdout);
  1226.  
  1227.     for (i=0;i<252;i++,*title?title++:0)
  1228.         putchar(*title?*title:0);
  1229.     
  1230.     for (i=0;i<xsize;i++)
  1231.         for (j=0;j<ysize;j++)
  1232.             pic[j][i]=getc(fp);
  1233.  
  1234.     for (j=0;j<ysize;j++)
  1235.         for(i=0;i<xsize;i++)
  1236.             putchar(pic[j][i]);
  1237.     
  1238.     fclose(fp);
  1239. }
  1240. End of convert.c
  1241.  echo convolve.c 1>&2
  1242. cat >convolve.c <<'End of convolve.c'
  1243. #include <stdio.h>
  1244. #include "image.h"
  1245.  
  1246. char *filtername=NULL;
  1247. int eflag = 0,
  1248.     fflag = 0;
  1249.  
  1250. typedef struct {
  1251.     char **image;
  1252.     short xsize,ysize;
  1253.     char title[252];
  1254. } FILTER;
  1255.  
  1256. main(argc,argv)
  1257. char **argv;
  1258. {
  1259.     char *imagefile=NULL;
  1260.     FILE *fp;
  1261.     IMAGE *image, *outimage;
  1262.     FILTER *filter, *loadfilter();
  1263.  
  1264.     stdopts(&argc,argv);
  1265.  
  1266.     if (helpflag) {
  1267.         help(*argv);
  1268.         exit(0);
  1269.     }
  1270.     
  1271.     for(argv++;*argv;argv++) 
  1272.         if ((**argv)=='-')
  1273.             switch ((*argv)[1]) {
  1274.             case 'e':
  1275.                 eflag=1;
  1276.                 break;
  1277.             case 'f':
  1278.                 filtername=argv[0]+2;
  1279.                 break;
  1280.             case 'F':
  1281.                 fflag=1;
  1282.                 break;
  1283.             }
  1284.         else imagefile= *argv;
  1285.     
  1286.     if (fflag) 
  1287.         execlp("ls","ls","-C","FILTERS_DIR");
  1288.     
  1289.     if (filtername) 
  1290.         filter=loadfilter(filtername);
  1291.     
  1292.     if (imagefile) {
  1293.         if (!(fp=fopen(imagefile,"r"))) {
  1294.             fprintf(stderr,"Couldn't open %s\n",imagefile);
  1295.             exit(-1);
  1296.         }
  1297.     }
  1298.     else fp = stdin;
  1299.     
  1300.     image=readimage(fp);
  1301.     outimage=newimage(image->xsize,image->ysize,(newtitle)?newtitle:image->title);
  1302.     if (filtername) {
  1303.         strcat(outimage->title," | ");
  1304.         strcat(outimage->title,filtername);
  1305.     }
  1306.  
  1307.     runfilter(filter,image,outimage);
  1308.  
  1309.     writeimage(stdout,outimage);
  1310. }
  1311.  
  1312. FILTER *
  1313. loadfilter(name)
  1314. char *name;
  1315. {
  1316.     char buf[BUFSIZ];
  1317.     FILE *fp;
  1318.     FILTER *filter;
  1319.     int xsize,ysize,ival;
  1320.     register int i,j;
  1321.  
  1322.     strcpy(buf,"FILTERS_DIR");
  1323.     strcat(buf,"/");
  1324.     strcat(buf,name);
  1325.  
  1326.     if (!(fp=fopen(buf,"r"))) {
  1327.         fprintf(stderr,"Couldn't open filter %s\n",name);
  1328.         exit(-1);
  1329.     }
  1330.     
  1331.     fscanf(fp,"%d %d",&xsize,&ysize);
  1332.     filter=(FILTER *)newimage(xsize,ysize,name);
  1333.  
  1334.     for(j=0;j<ysize;j++)
  1335.         for(i=0;i<xsize;i++) {
  1336.             fscanf(fp,"%d",&ival);
  1337.             filter->image[j][i]=ival;
  1338.         }
  1339.     
  1340.     return filter;
  1341. }
  1342.  
  1343. runfilter(filter,image,outimage)
  1344. IMAGE *image, *outimage;
  1345. FILTER *filter;
  1346. {
  1347.     int nflag = 0,
  1348.         scale,
  1349.         total;
  1350.     short max= -32768,
  1351.           min=  32767,
  1352.           **tempimage;
  1353.     int mfy = filter->ysize>>1,
  1354.         mfx = filter->xsize>>1;
  1355.     register int fi,fj,i,j;
  1356.     int sneg=0,
  1357.         spos=0,
  1358.         fred;
  1359.  
  1360.     for(j=0;j<filter->ysize;j++)
  1361.         for(i=0;i<filter->xsize;i++)
  1362.             if (filter->image[j][i]<0) {
  1363.                 nflag=1;
  1364.                 sneg -= filter->image[j][i];
  1365.             }
  1366.             else spos += filter->image[j][i];
  1367.  
  1368.     scale = (sneg > spos) ? sneg : spos;
  1369.     scale = (nflag) ? scale*2 : scale;
  1370.  
  1371.     if (!eflag)
  1372.         for(j=0;j<image->ysize-filter->ysize;j++)
  1373.             for(i=0;i<image->xsize-filter->ysize;i++) {
  1374.                 total=0;
  1375.                 for(fj=0;fj<filter->ysize;fj++)
  1376.                     for(fi=0;fi<filter->xsize;fi++) {
  1377.                         fred = image->image[j+fj][i+fi];
  1378.                         total += fred * filter->image[fj][fi];
  1379.                     }
  1380.                 outimage->image[j+mfy][i+mfx] = total / scale + ((nflag) ? 128 : 0);
  1381.             }
  1382.     else {
  1383.         if (!(tempimage=(short **)
  1384.                 dynamem(&tempimage,sizeof(short),2,image->ysize,image->xsize))) {
  1385.             fprintf(stderr,"Get some more VM !!!\n");
  1386.             exit(-1);
  1387.         }
  1388.         for(j=0;j<image->ysize-filter->ysize;j++)
  1389.             for(i=0;i<image->xsize-filter->ysize;i++) {
  1390.                 total=0;
  1391.                 for(fj=0;fj<filter->ysize;fj++)
  1392.                     for(fi=0;fi<filter->xsize;fi++) {
  1393.                         fred = image->image[j+fj][i+fi];
  1394.                         total += filter->image[fj][fi] * fred;
  1395.                     }
  1396.                 tempimage[j+mfy][i+mfx] = total;
  1397.                 max=(max>total)?max:total;
  1398.                 min=(min<total)?min:total;
  1399.             }
  1400.  
  1401.         scale=(max>-min)?max:-min;
  1402.         scale=(nflag)?scale*2:scale;
  1403.  
  1404.         for (j=0; j< image->ysize; j++)
  1405.             for (i=0; i<image->xsize;i++)
  1406.                 outimage->image[j][i]=tempimage[j][i]*256/scale+((nflag)?128:0);
  1407.     }
  1408. }
  1409.  
  1410. help(name)
  1411. char *name;
  1412. {
  1413.     printf("Convolution Filter\n");
  1414.     printf("------------------\n");
  1415.     printf("\nUsage: %s [file]\n",name);
  1416.     printf("\nOptions:\n");
  1417.     printf("  -F       list filters\n");
  1418.     printf("  -ffilter use filter\n");
  1419.     printf("  -e       enhanced scaling\n");
  1420.     printf("  -h       help\n");
  1421. }
  1422. End of convolve.c
  1423.  echo defs.h 1>&2
  1424. cat >defs.h <<'End of defs.h'
  1425. #define YES     1
  1426. #define NO   0
  1427. #define FILTERS_DIR        "/usr/aloha/alv/everson/usr/filters"
  1428. #define ERROR(S)    { fprintf(stderr,"%s: %s\n",progname,S); exit(1); }
  1429. #define FIL_MAX     31            /* max dimension of a filter */
  1430. #define XSIZE        256
  1431. #define    YSIZE        240
  1432.  
  1433. int filter[FIL_MAX][FIL_MAX];            /* filter array */
  1434. char progname[10];        /* program name */
  1435. short old_maxch,        /* max pixel value in the picture */
  1436.       old_minch,        /* min pixel value in the picture */
  1437.       maxch,            /* max pixel value in image */
  1438.       minch,            /* min pixel value in image */
  1439.       abs_minch;        /* min absolute pixel value in image */
  1440.  
  1441. unsigned char **pic,
  1442.               **image;;
  1443. short **eimage;
  1444.  
  1445. int pic_trunc;                /* truncation value */
  1446. int xsize,
  1447.     ysize,
  1448.     m_fil,                /* height of filter */
  1449.     n_fil,                /* width of filter */
  1450.     fil_scale;            /* scaling factor used to scale image to character
  1451.                            values after running the filter */
  1452. extern int negfilter,
  1453.            enhanced;
  1454. End of defs.h
  1455.  echo dsp.c 1>&2
  1456. cat >dsp.c <<'End of dsp.c'
  1457. #include <suntool/sunview.h>
  1458. #include <suntool/canvas.h>
  1459. #include <stdio.h>
  1460. #include "image.h"
  1461. #include "pattern3.h"
  1462.  
  1463. int boxsize = 3;
  1464. static void getcoords();
  1465. static void repaint_canvas();
  1466. IMAGE *image;
  1467. int *p_pat;
  1468. int mflag = 0;
  1469. Pixrect *pattern;
  1470.  
  1471. main(argc, argv)
  1472. int argc;
  1473. char **argv;
  1474. {
  1475.     Frame frame;
  1476.     Canvas canvas;
  1477.     Pixwin *pw;
  1478.     char cmsname[CMS_NAMESIZE];
  1479.     int i, j, x, y;
  1480.     FILE *fp, *fopen();
  1481.     u_char *pi;
  1482.     char *imagefile=NULL;
  1483.  
  1484.     stdopts(&argc,argv);
  1485.     windopts(&argc,argv);
  1486.  
  1487.     for (argv++;*argv;*argv++)
  1488.         if (*argv[0]=='-' && (*argv)[1]=='m') 
  1489.             mflag = 1;
  1490.         else imagefile= *argv;
  1491.  
  1492.     if (imagefile==NULL)
  1493.         fp=stdin;
  1494.     else if (!(fp = fopen(imagefile,"r"))) {
  1495.         fprintf(stderr,"Cannot open %s\n",imagefile);
  1496.         exit(-1);
  1497.         }
  1498.     image = readimage(fp);
  1499.  
  1500.     /* create frame and canvas */
  1501.     frame = window_create(NULL, FRAME,
  1502.                   FRAME_LABEL, (newtitle)?newtitle:image->title,
  1503.                   WIN_X, winxoff,
  1504.                   WIN_Y, winyoff,
  1505.                   WIN_HEIGHT, (winxsize)?winxsize:image->ysize * boxsize + 22,
  1506.                   WIN_WIDTH, (winysize)?winysize:image->xsize * boxsize + 10,
  1507.                   0);
  1508.  
  1509.  
  1510.     if (mflag)
  1511.         canvas = window_create(frame, CANVAS,
  1512.                        CANVAS_HEIGHT, image->ysize * boxsize,
  1513.                        CANVAS_WIDTH, image->xsize * boxsize,
  1514.                        WIN_EVENT_PROC, getcoords,
  1515.                        0);
  1516.     else
  1517.         canvas = window_create(frame, CANVAS,
  1518.                        CANVAS_FAST_MONO, TRUE,
  1519.                        CANVAS_HEIGHT, image->ysize * boxsize,
  1520.                        CANVAS_WIDTH, image->xsize * boxsize,
  1521.                        WIN_EVENT_PROC, getcoords,
  1522.                        CANVAS_RETAINED, FALSE,
  1523.                        CANVAS_REPAINT_PROC, repaint_canvas,
  1524.                        0);
  1525.  
  1526.  
  1527.     /* get the canvas pixwin to draw into */
  1528.     pw = canvas_pixwin(canvas);
  1529.  
  1530.     /* create dot pattern */
  1531.     pattern = mem_create(boxsize, boxsize * 50, 1);
  1532.     p_pat = &pat[0];
  1533.     for (y = 0; y < boxsize * 10; y++)
  1534.         for (x = 0; x < boxsize; x++, p_pat++)
  1535.             pr_rop(pattern, x, y, 1, 1,
  1536.                    (*p_pat) ? PIX_CLR : PIX_SET,
  1537.                    (Pixrect *) 0, 0, 0);
  1538.  
  1539.     if (mflag) {
  1540.         /* Draw gray boxes */
  1541.         for (y = 0; y < image->ysize; y++) {
  1542.             pi = image->image[y];
  1543.             for (x = 0; x < image->xsize; x++) {
  1544.                 /* Fill in a square box */
  1545.                 pw_rop(pw, x * boxsize, y * boxsize,
  1546.                        boxsize, boxsize,
  1547.                        PIX_SRC, pattern, 0, boxsize * ((*pi + 26) / 27));
  1548.                 pi++;
  1549.             }
  1550.         }
  1551.     }
  1552.  
  1553.     window_main_loop(frame);
  1554. }
  1555.  
  1556. static void
  1557. repaint_canvas(canvas, pw, repaint_area)
  1558. Canvas canvas;
  1559. Pixwin *pw;
  1560. Rectlist *repaint_area;
  1561.  
  1562. {
  1563.     u_char *pi;
  1564.     int x, y;
  1565.     int xstart, ystart, xstop, ystop;
  1566.  
  1567.     xstart = repaint_area->rl_bound.r_left / boxsize;
  1568.     ystart = repaint_area->rl_bound.r_top / boxsize;
  1569.     xstop = xstart + 1 + repaint_area->rl_bound.r_width / boxsize;
  1570.     ystop = ystart + 1 + repaint_area->rl_bound.r_height / boxsize;
  1571.  
  1572.     xstop = (xstop > image->xsize) ? image->xsize : xstop;
  1573.     ystop = (ystop > image->ysize) ? image->ysize : ystop;
  1574.  
  1575.     /* Enable locking for efficiency */
  1576.  
  1577.     /* Draw gray boxes */
  1578.     for (y = ystart; y < ystop; y++) {
  1579.         pi = &(image->image[y][xstart]);
  1580.         pw_lock(pw, &(repaint_area->rl_bound));
  1581.         for (x = xstart; x < xstop; x++) {
  1582.             /* Fill in a square box */
  1583.             pw_rop(pw, x * boxsize, y * boxsize,
  1584.                    boxsize, boxsize,
  1585.               PIX_SRC, pattern, 0, boxsize * ((*pi + 26) / 27));
  1586.             pi++;
  1587.         }
  1588.         pw_unlock(pw);
  1589.     }
  1590. }
  1591.  
  1592. static void
  1593. getcoords(canvas, event, arg)
  1594. Canvas canvas;
  1595. Event *event;
  1596. caddr_t arg;
  1597.  
  1598. {
  1599.     if ((event_id(event) == MS_LEFT) && event_is_down(event)) {
  1600.         printf("%s: locator x,y : %d %d  greylevel = %d\n", (newtitle)?newtitle:image->title,
  1601.                event_x(event) / boxsize, event_y(event) / boxsize,
  1602.          image->image[event_y(event) / boxsize][event_x(event) / boxsize]);
  1603.     }
  1604. }
  1605. End of dsp.c
  1606.  echo dynamem.3 1>&2
  1607. cat >dynamem.3 <<'End of dynamem.3'
  1608. .\" .TH name section cent-foot left-foot cent-head
  1609. .TH DYNAMEM 3 "28 August 1987"
  1610. .SH NAME
  1611. .\" name \- function
  1612. dynamem, freeup \- multidimensional dynamic array handling
  1613. .SH SYNOPSIS
  1614. .\" Bold keywords, Italic variables, [] options, | alternatives.
  1615. .br
  1616. .B char *dynamem(pointer,element_size,
  1617. .br
  1618. .B                 number_dimensions,dimensions ...)
  1619. .br
  1620. .B char **pointer;
  1621.  
  1622. .br
  1623. .B freeup(pointer)
  1624. .br
  1625. .B char *pointer;
  1626.  
  1627. .SH DESCRIPTION
  1628. .\" Italic files, commands, IR manual-entry (manual-section)
  1629. .I dynamem 
  1630. is the multidimensional analogue to malloc().
  1631. It is passed a number of arguments: a pointer which on
  1632. exiting the procedure will point to the begining of the
  1633. array, the element size, the number of dimensions 
  1634. required, followed by a list of the dimension sizes. 
  1635. To declare a 4 dimensional array normally one would code:
  1636. .DS L
  1637.  
  1638. int array[10][11][12][13];
  1639.  
  1640. .DE
  1641. however, this array is then fixed at compile time. This
  1642. same array can be declared dynamically at run time 
  1643. using the following code:
  1644. .DS L
  1645.  
  1646. int ****array;
  1647.  
  1648. array = (int ****) dynamem(&array, sizeof(int), 4, 10, 11, 12, 13);
  1649.  
  1650. .DE
  1651. (Note that the number of levels of indirection in the cast
  1652. is equal to the number of dimensions in the array.)
  1653. This enables array sizes to be fixed via, for example, 
  1654. command line arguments. 
  1655. .PP
  1656. .I freeup
  1657. is the 
  1658. .I dynamem
  1659. analogue to free(). When passed an array previously 
  1660. dynamically declared by 
  1661. .I dynamem
  1662. the function returns this memory to the system.
  1663. .PP
  1664. .I dynamem
  1665. attempts to set up the array required in the same way that 
  1666. it would be set up by the compiler at compile time. Thus
  1667. a multidimensional dynamically array declared using 
  1668. .I dynamem
  1669. can be used in exactly the same way as a fixed array declared
  1670. by the compiler. There is obviously some overhead in the actual
  1671. setting up of the array; however, this is minimal: 
  1672. when dynamically allocating 2 arrays of 346000
  1673. unsigned characters and one of the same number of shorts all in
  1674. two dimensions, the run time of a convolution of a 7x7 Lapacian-
  1675. Marr filter over an image of size 720 by 480 varied as follows:
  1676. .sp 1
  1677. time convolve -fbfilt -X720 -Y480 -e < bubble2 > test.1
  1678. .br
  1679.       222.0 real       213.4 user         1.6 sys  
  1680. .sp 1
  1681. time convolve -fbfilt -e < bubble2 > test.2
  1682. .br
  1683.       225.2 real       212.5 user         2.7 sys  
  1684. .sp 1
  1685. which is probably adequate. From this we can see that 
  1686. it takes 1.1 secs for the fixed array to be set up
  1687. and zeroed and only 0.9 secs for the array to be
  1688. dynamically declared using
  1689. .IR dynamem ; 
  1690. however, using dynamem the array is not initialized to
  1691. 0 and this is the reason for the 0.2 speed increase.
  1692. .SH FILES
  1693. .\" List of all files used by the program
  1694. /users/alv/everson/usr/lib/dynamem.a
  1695. .SH "SEE ALSO"
  1696. .\" List of references, textual, and MAN pages.
  1697. malloc(3), convolve(1)
  1698. .SH DIAGNOSTICS
  1699. .\" List of error messages and return codes the user may expect
  1700. .br
  1701. .I dynamem
  1702. returns NULL if it is unable to allocate sufficient
  1703. memory for the array.
  1704. End of dynamem.3
  1705.  echo dynamem.c 1>&2
  1706. cat >dynamem.c <<'End of dynamem.c'
  1707.  
  1708. /*
  1709.  * dynamem allocates a d dimensional array, whose dimensions are stored in a
  1710.  * list starting at d1. Each array element is of size s. p is a pointer with
  1711.  * d levels of indirection to the memory area 
  1712.  */
  1713.  
  1714. char *
  1715. dynamem(p, s, d, d1)
  1716. char **p;
  1717. int s, d, d1;
  1718. {
  1719.     int max,        /* size of array to be declared */
  1720.     *q;            /* pointer to dimension list */
  1721.     char **r,        /* pointer to begining of the array of the
  1722.                  * pointers for a dimension */
  1723.     **s1, *t, *tree;    /* base pointer to begining of first array */
  1724.     int i,            /* loop counters */
  1725.      j;
  1726.  
  1727.     r = &tree;
  1728.     q = &d1;        /* first dimension */
  1729.     max = 1;
  1730.     for (i = 0; i < d - 1; i++, q++) {    /* for each of the dimensions
  1731.                          * but the last */
  1732.         max *= (*q);
  1733.         if ((r[0] = (char *) malloc((unsigned) max * sizeof (char **))) == 0) {
  1734.             freeup(tree);
  1735.             return 0;
  1736.         }
  1737.         r = (char **) r[0];    /* step through to begining of next
  1738.                      * dimension array */
  1739.     }
  1740.     max *= s * (*q);    /* grab actual array memory */
  1741.     if ((r[0] = (char *) malloc((unsigned) max)) == 0) {
  1742.         freeup(tree);
  1743.         return 0;
  1744.     }
  1745.  
  1746.     /*
  1747.      * r is now set to point to the begining of each array so that we can
  1748.      * use it to scan down each array rather than having to go across and
  1749.      * then down 
  1750.      */
  1751.     r = (char **) tree;    /* back to the begining of list of arrays */
  1752.     q = &d1;        /* back to the first dimension */
  1753.     max = 1;
  1754.     for (i = 0; i < d - 2; i++, q++) {    /* we deal with the last
  1755.                          * array of pointers later on */
  1756.         max *= (*q);    /* number of elements in this dimension */
  1757.         for (j = 1, s1 = r + 1, t = r[0]; j < max; j++)    /* scans down array for
  1758.                                  * first and subsequent
  1759.                                  * elements */
  1760.  
  1761.             /*
  1762.              *  modify each of the pointers so that it points to
  1763.              * the correct position (sub-array) of the next
  1764.              * dimension array. s1 is the current position in the
  1765.              * current array. t is the current position in the
  1766.              * next array. t is incremented before s is, but it
  1767.              * starts off one behind. *(q+1) is the dimension of
  1768.              * the next array. 
  1769.              */
  1770.             *s1++ = (t += sizeof (char **) * *(q + 1));
  1771.         r = (char **) r[0];    /* step through to begining of next
  1772.                      * dimension array */
  1773.     }
  1774.     max *= (*q);        /* max is total number of elements in the
  1775.                  * last pointer array */
  1776.     for (j = 1, s1 = r + 1, t = r[0]; j < max; j++)    /* same as previous
  1777.                              * loop, but different
  1778.                              * size factor */
  1779.         *s1++ = (t += s * *(q + 1));
  1780.     return tree;        /* return base pointer */
  1781. }
  1782.  
  1783. /*
  1784.  * freeup releases all memory that we have already declared analogous to
  1785.  * free() when using malloc() 
  1786.  */
  1787. freeup(r)
  1788. char *r;
  1789. {
  1790.     char **p;
  1791.  
  1792.     for (p = &r; p; p = (char **) *p)
  1793.         free(*p);
  1794. }
  1795. End of dynamem.c
  1796.  echo ffill.c 1>&2
  1797. cat >ffill.c <<'End of ffill.c'
  1798. #include <stdio.h>
  1799. #include "image.h"
  1800.  
  1801. IMAGE *image;
  1802.  
  1803. main(argc,argv)
  1804. char **argv;
  1805. {
  1806.     FILE *fp;
  1807.     int xpos = -1, ypos = -1;
  1808.     int boundary = 0;
  1809.     char *imagefile=NULL;
  1810.  
  1811.     stdopts(&argc,argv);
  1812.  
  1813.     for (argv++;*argv;*argv++)
  1814.         if (**argv=='-')
  1815.             switch ((*argv)[1]) {
  1816.             case 'b':
  1817.                 boundary=atoi(argv[0]+2);
  1818.                 break;
  1819.             }
  1820.         else if (xpos<0)
  1821.             xpos=atoi(*argv+2);
  1822.         else if (ypos<0)
  1823.             ypos=atoi(*argv+2);
  1824.         else
  1825.             imagefile = *argv;
  1826.  
  1827.     if (imagefile==NULL)
  1828.         fp=stdin;
  1829.     else if (!(fp=fopen(imagefile,"r"))) {
  1830.         fprintf(stderr,"Cannot open %s\n",imagefile);
  1831.         exit(-1);
  1832.         }
  1833.  
  1834.     image=readimage(fp);
  1835.  
  1836.     if (!newtitle)
  1837.         sprintf(image->title,"%s | ffill %d %d %d\n",image->title,xpos,ypos,boundary);
  1838.     else
  1839.         strcpy(image->title,newtitle);
  1840.     ffill(xpos,ypos,boundary);
  1841.  
  1842.     writeimage(stdout,image);
  1843.     
  1844. }
  1845.  
  1846. ffill(x,y,n)
  1847. {
  1848. int i,j,k;
  1849.  
  1850.     if (x<0 || x>=image->xsize || y<0 || y>=image->ysize|| ftest(x,y)==n)
  1851.         return;
  1852.     fset (x,y,n);
  1853.     for (i=x-1;i>=0;i--) {
  1854.         if (ftest(i,y)!=n)
  1855.             fset(i,y,n);
  1856.         else 
  1857.             break;
  1858.         }
  1859.     for (j=x+1;j<image->xsize;j++)
  1860.         if (ftest(j,y)!=n)
  1861.             fset(j,y,n);
  1862.         else 
  1863.             break;
  1864.     for (k=i+1;k<j;k++)
  1865.     {
  1866.         if (y>0 && ftest(k,y-1)!=n)
  1867.             ffill(k,y-1,n);
  1868.         if (y<image->ysize-1 && ftest(k,y+1)!=n)
  1869.             ffill(k,y+1,n);
  1870.     }
  1871. }
  1872.  
  1873. ftest(x,y)
  1874. {
  1875.     return image->image[y][x];
  1876. }
  1877.  
  1878. fset(x,y,n)
  1879. {
  1880.     image->image[y][x]=n;
  1881. }
  1882.  
  1883. End of ffill.c
  1884.  echo hist.c 1>&2
  1885. cat >hist.c <<'End of hist.c'
  1886. #include <suntool/sunview.h>
  1887. #include <suntool/canvas.h>
  1888. #include <stdio.h>
  1889. #include <math.h>
  1890. #include "image.h"
  1891.  
  1892. static short histicon[] = 
  1893. {
  1894. #include "hist.icon"
  1895. };
  1896. DEFINE_ICON_FROM_IMAGE(icon,histicon);
  1897.  
  1898. #define GREYLEVELS    256
  1899. #define HSIZE    128
  1900. #define HEADER    10
  1901. #define BOTTOM    20
  1902. #define BOXSIZE    3
  1903. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  1904. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  1905.  
  1906. IMAGE *image;
  1907. int vflag=1,
  1908.     lflag=0;
  1909. Frame frame;
  1910. Canvas canvas;
  1911. Menu menu;
  1912. Pixwin *pw;
  1913. int hist[GREYLEVELS],
  1914.     n=0;
  1915.  
  1916. main(argc,argv)
  1917. int argc;
  1918. char **argv;
  1919. {
  1920.     double mean(),
  1921.            lhist[GREYLEVELS],
  1922.            ldummy,
  1923.            lmaxh= -10000.0;
  1924.     register short i,j;
  1925.     int c,
  1926.         mo,
  1927.         len,
  1928.         dummy,
  1929.         maxh=0,
  1930.         maxc=0,
  1931.         minc=GREYLEVELS;
  1932.     Pixrect *pattern;
  1933.     char *imagefile=NULL;
  1934.     char message[BUFSIZ];
  1935.     FILE *fp;
  1936.  
  1937.     stdopts(&argc,argv);
  1938.     windopts(&argc,argv);
  1939.  
  1940.     for (argv++;*argv;*argv++)
  1941.         if (**argv=='-')
  1942.             switch ((*argv)[1]) {
  1943.             case 'l':
  1944.                 lflag=1;
  1945.                 break;
  1946.             case 'v':
  1947.                 vflag=0;
  1948.                 break;
  1949.             }
  1950.         else imagefile = *argv;
  1951.  
  1952.     if (imagefile==NULL)
  1953.         fp=stdin;
  1954.     else if (!(fp=fopen(imagefile,"r"))) {
  1955.         fprintf(stderr,"Cannot open %s\n",imagefile);
  1956.         exit(-1);
  1957.         }
  1958.  
  1959.     image=readimage(fp);
  1960.     
  1961.     for (i=0;i<GREYLEVELS;i++)
  1962.         hist[i]=0;
  1963.  
  1964.     for(j=0;j<image->ysize;j++) 
  1965.         for (i=0;i<image->xsize;i++) {
  1966.             c = MAX(image->image[j][i],0);
  1967.             c = MIN(c,GREYLEVELS);
  1968.             if (c>maxc) 
  1969.                 maxc = c;
  1970.             else if (c<minc) 
  1971.                 minc = c;
  1972.             hist[c]++;
  1973.             if (maxh<hist[c])
  1974.                 maxh=hist[c];
  1975.             n++;
  1976.         }
  1977.  
  1978.     fprintf(stderr,"mean pixel = %3g\n",mean());
  1979.     fprintf(stderr,"median pixel = %d\n",median());
  1980.     fprintf(stderr,"mode pixel = %d\n",mo=mode());
  1981.     fprintf(stderr,"max pixel = %d\nmin pixel = %d\n",maxc,minc);
  1982.  
  1983.     strcpy(message,(lflag==1)?"logarithmic histogram" : "histogram");
  1984.     strcat(message,": ");
  1985.     strcat(message,image->title);
  1986.  
  1987.        /* create frame and canvas */
  1988.        frame = window_create(NULL, FRAME,
  1989.              FRAME_LABEL, message, 
  1990.              WIN_X, winxoff,
  1991.              WIN_Y, winyoff,
  1992.              WIN_HEIGHT, (winxsize)?winxsize:HSIZE+28+HEADER+BOTTOM,
  1993.              WIN_WIDTH, (winysize)?winysize:(GREYLEVELS*BOXSIZE)+10,
  1994.              FRAME_ICON,&icon,
  1995.              0);
  1996.        canvas = window_create(frame, CANVAS,
  1997.               CANVAS_FAST_MONO, TRUE,
  1998.               CANVAS_HEIGHT, HSIZE+HEADER+BOTTOM,
  1999.               CANVAS_WIDTH, GREYLEVELS*BOXSIZE,
  2000.               0);
  2001.       
  2002.     /* get the cancas pixwin to draw into */
  2003.        pw = canvas_pixwin(canvas);
  2004.  
  2005.       /* Enable batching for efficiency */
  2006.        pw_batch_on(pw);
  2007.  
  2008.        if (!lflag) { 
  2009.            for (i = 0; i < GREYLEVELS; i++) {
  2010.             dummy = hist[i]*HSIZE/maxh;
  2011.             if (!dummy && hist[i]) 
  2012.                 dummy = 1;
  2013.              if (vflag) {
  2014.                 pw_vector(pw,i*BOXSIZE,HSIZE+HEADER-dummy,i*BOXSIZE,HSIZE+HEADER,PIX_SET,1);
  2015.                 pw_vector(pw,i*BOXSIZE+BOXSIZE,HSIZE+HEADER-dummy,i*BOXSIZE+BOXSIZE,HSIZE+HEADER,PIX_SET,1);
  2016.                 }
  2017.             pw_rop(pw,i*BOXSIZE,HSIZE+HEADER-dummy,BOXSIZE,1,PIX_SET,(Pixrect *)0,0,0);
  2018.                }    
  2019.         }
  2020.     else {
  2021.         for (i=0;i<GREYLEVELS;i++) {
  2022.             lhist[i] = log((double)hist[i]+1.0);        /* add 1 to avoid log(0) */
  2023.             if (lmaxh<lhist[i])
  2024.                 lmaxh=lhist[i];
  2025.             }
  2026.         for (i=0;i<GREYLEVELS;i++) {
  2027.             ldummy = lhist[i]*HSIZE /lmaxh; 
  2028.             if (dummy!=0.0 && lhist[i]==0.0)
  2029.                 ldummy = 1.0;
  2030.              if (vflag) {
  2031.                 pw_vector(pw,i*BOXSIZE,HSIZE+HEADER-(int)ldummy,i*BOXSIZE,HSIZE+HEADER,PIX_SET,1);
  2032.                 pw_vector(pw,i*BOXSIZE+BOXSIZE,HSIZE+HEADER-(int)ldummy,i*BOXSIZE+BOXSIZE,HSIZE+HEADER,PIX_SET,1);
  2033.                 }
  2034.             pw_rop(pw,i*BOXSIZE,HSIZE+HEADER-(int)ldummy,BOXSIZE,1,
  2035.             PIX_SET,(Pixrect *)0,0,0);
  2036.             }
  2037.         }
  2038.  
  2039.     /* print bottom axis */
  2040.     pw_vector(pw,0,HSIZE+HEADER,image->xsize*BOXSIZE,HSIZE+HEADER,PIX_SET,1);
  2041.     for(i=0;i<GREYLEVELS;i++) {
  2042.         len = (i%100==0) ? 10 :
  2043.               (i%50==0)  ? 8 :
  2044.               (i%10==0)  ? 6 :
  2045.               (i%2==0)   ? 5 : 0;
  2046.         if (len)
  2047.             pw_vector(pw,i*BOXSIZE,HSIZE+HEADER,i*BOXSIZE,HSIZE+HEADER+len,PIX_SET,1);
  2048.         }
  2049.  
  2050.     pw_batch_off(pw);
  2051.        window_main_loop(frame);
  2052.  
  2053.     exit(0);
  2054. }
  2055.  
  2056. double mean()
  2057. {
  2058.     int i;
  2059.     double m=0;
  2060.  
  2061.     for (i=0;i<GREYLEVELS;i++)  {
  2062.         m += hist[i]*i;    
  2063.         }
  2064.     return m/n;
  2065. }
  2066.     
  2067. median()
  2068. {
  2069.     int i=0,
  2070.         count=0;
  2071.     
  2072.     while (count<n/2) 
  2073.         count += hist[i++];
  2074.     return i-1;
  2075. }
  2076.  
  2077. mode()
  2078. {
  2079.     int i=0;
  2080.     int mo=0,
  2081.         m=0;
  2082.  
  2083.     for(i=0;i<GREYLEVELS;i++)
  2084.         if (hist[i]>m) {
  2085.             m=hist[i];
  2086.             mo=i;
  2087.             }
  2088.  
  2089.     return mo;
  2090. }
  2091.  
  2092. End of hist.c
  2093.  echo hist.icon 1>&2
  2094. cat >hist.icon <<'End of hist.icon'
  2095. /* Format_version=1, Width=64, Height=64, Depth=1, Valid_bits_per_item=16
  2096.  */
  2097.     0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x8000,0x0000,0x0000,0x0001,
  2098.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2099.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2100.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2101.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2102.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2103.     0x8000,0x0000,0x2000,0x0001,0x8000,0x0000,0x2000,0x0001,
  2104.     0x8000,0x0000,0x2000,0x0001,0x8000,0x0000,0x2000,0x0001,
  2105.     0x8002,0x0800,0x2008,0x0001,0x8002,0x0800,0x2008,0x0001,
  2106.     0x8002,0x0800,0x2008,0x0001,0x8002,0x0800,0x2008,0x0001,
  2107.     0x800A,0x0A00,0x2008,0x8081,0x800A,0x0A00,0x2008,0x8081,
  2108.     0x800A,0x0A00,0x2008,0x8081,0x800A,0x0A00,0x2008,0x8081,
  2109.     0x800A,0x0A00,0x2808,0x8081,0x800A,0x0A00,0x2808,0x8081,
  2110.     0x800A,0x0A00,0x2808,0x8081,0x800A,0x0A00,0x2808,0x8081,
  2111.     0x800A,0x8A00,0x2888,0x8281,0x800A,0x8A00,0x2888,0x8281,
  2112.     0x800A,0x8A00,0x2888,0x8281,0x800A,0x8A00,0x2888,0x8281,
  2113.     0x800A,0x8A00,0xA8A8,0x8281,0x800A,0x8A00,0xA8A8,0x8281,
  2114.     0x800A,0x8A00,0xA8A8,0x8281,0x800A,0x8A02,0xA8A8,0x8A81,
  2115.     0x802A,0x8A8A,0xAAAA,0x8A81,0x802A,0x8A8A,0xAAAA,0x8A81,
  2116.     0x802A,0x8A8A,0xAAAA,0x8A81,0x802A,0x8A8A,0xAAAA,0x8A81,
  2117.     0x80AA,0xAAAA,0xAAAA,0xAA81,0x80AA,0xAAAA,0xAAAA,0xAA81,
  2118.     0x80AA,0xAAAA,0xAAAA,0xAA81,0x80FF,0xFFFF,0xFFFF,0xFF81,
  2119.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2120.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2121.     0xA010,0x0040,0x0000,0x0001,0xA000,0x0040,0x0000,0x0001,
  2122.     0xAC70,0x71F1,0xC34B,0x0E35,0xB210,0x8842,0x24CC,0x912B,
  2123.     0xA210,0x8042,0x2448,0x012B,0xA210,0x7042,0x2448,0x0F2B,
  2124.     0xA210,0x0842,0x2448,0x112B,0xA210,0x8842,0x24C8,0x112B,
  2125.     0xA210,0x7031,0xC348,0x0F2B,0x8000,0x0000,0x0040,0x0001,
  2126.     0x8000,0x0000,0x0440,0x0001,0x8000,0x0000,0x0380,0x0001,
  2127.     0x8000,0x0000,0x0000,0x0001,0x8000,0x0000,0x0000,0x0001,
  2128.     0x8000,0x0000,0x0000,0x0001,0xFFFF,0xFFFF,0xFFFF,0xFFFF
  2129. End of hist.icon
  2130.  echo image.h 1>&2
  2131. cat >image.h <<'End of image.h'
  2132. typedef struct img {
  2133.     unsigned char **image;
  2134.     short xsize, ysize;
  2135.     char title[252];
  2136. } IMAGE;
  2137.  
  2138. IMAGE *readimage(), *newimage();
  2139.  
  2140. extern int winxsize,winysize,
  2141.            winxoff, winyoff;
  2142. extern int helpflag;
  2143. extern char *newtitle;
  2144. End of image.h
  2145.  echo imagelw.c 1>&2
  2146. cat >imagelw.c <<'End of imagelw.c'
  2147. #include <stdio.h>
  2148. #include <ctype.h> 
  2149. #include "image.h"
  2150. #define MIDX        285             /* center of output page */
  2151. #define MIDY        396
  2152.  
  2153. IMAGE *image;
  2154.  
  2155. main (argc,argv)
  2156. int argc;
  2157. char **argv;
  2158. {
  2159.     int c,x=0,y=0,r=0;
  2160.     register int i,j;
  2161.     double sx=1.0,sy=1.0,atof();
  2162.     char *hex();
  2163.     char title[512],buf[512];
  2164.     FILE *fp,*p1;
  2165.     int sflag=0,mflag=0,oflag=0,cflag=0;
  2166.     char *imagefile=NULL;
  2167.     
  2168.     stdopts(&argc,argv);
  2169.     windopts(&argc,argv);
  2170.  
  2171.     for (argv++;*argv;*argv++)
  2172.         if (**argv=='-')
  2173.             switch ((*argv)[1]) {
  2174.             case 't':
  2175.                 sflag=1;
  2176.                 break;
  2177.             case 'm':
  2178.                 mflag=1;
  2179.                 break;
  2180.             case 'c':
  2181.                 cflag=1;
  2182.                 break;
  2183.             case '\0':
  2184.                 oflag=1;
  2185.                 break;
  2186.             }
  2187.         else
  2188.             imagefile = *argv;
  2189.  
  2190.     if (imagefile==NULL)
  2191.         fp=stdin;
  2192.     else if (!(fp=fopen(imagefile,"r"))) {
  2193.         fprintf(stderr,"Cannot open %s\n",imagefile);
  2194.         exit(-1);
  2195.         }
  2196.  
  2197.     image=readimage(fp);
  2198.     
  2199.     if (oflag || sflag)
  2200.         p1=stdout;
  2201.     else if((p1=popen(strcat("lpr -Plw -v",((mflag)?" -m":"")),"w"))==NULL) {
  2202.             fprintf(stderr,"Cannot open pipe to lpr\n");
  2203.             exit(-1);
  2204.             }
  2205.     
  2206.     fprintf(p1,"/picstr %d string def\n",image->xsize);
  2207.  
  2208.     if (image->title[0]) {
  2209.         fprintf(p1,"/Helvetica-Bold findfont\n");
  2210.         fprintf(p1,"12 scalefont setfont\n");
  2211.         fprintf(p1,"285 (%s) stringwidth pop 2 div sub 720 moveto\n",image->title);
  2212.         fprintf(p1,"(%s) show\n",image->title);
  2213.         }
  2214.     if (cflag) {
  2215.         sx=7.91*300/image->xsize;
  2216.         sy=8.5*300/image->ysize;                /* avoid title area */
  2217.         sx=sy=(sx>sy) ? sy:sx;
  2218.         x= -sx*image->xsize*72/300/2;
  2219.         y= -sy*image->ysize*72/300/2;
  2220.         }
  2221.     if (sflag) 
  2222.         fprintf(p1," 0 0 translate\n");
  2223.     else fprintf(p1,"%d %d translate\n",MIDX+x,MIDY-36+y);
  2224.  
  2225.     fprintf(p1,"%d %d scale\n",(int)(image->xsize/300.0*72.0*sx),(int)(image->ysize/300.0*72.0*sy));
  2226.     fprintf(p1,"%d %d 8\n",image->xsize,image->ysize);
  2227.     fprintf(p1,"[ %d 0 0 -%d 0 %d ]\n",image->xsize,image->ysize,image->ysize);
  2228.     fprintf(p1,"{currentfile\npicstr readhexstring pop}\nimage\n");
  2229.  
  2230.     for(j=0;j<image->ysize;j++)
  2231.         for(i=0;i<image->xsize;i++)
  2232.             fputs(hex(image->image[j][i]),p1);
  2233.  
  2234.     if (!sflag)
  2235.         fprintf(p1,"showpage\n");
  2236.     if (!(oflag || sflag))
  2237.         pclose(p1);
  2238. }
  2239.  
  2240. char *hex(d)
  2241. {
  2242.     static char a[10];
  2243.  
  2244.     sprintf(a,"%02x",d);
  2245.     return(a);
  2246. }
  2247. End of imagelw.c
  2248.  echo invert.c 1>&2
  2249. cat >invert.c <<'End of invert.c'
  2250. #include <stdio.h>
  2251. #include "image.h"
  2252.  
  2253. main(argc,argv)
  2254. char **argv;
  2255. {
  2256.     int c;
  2257.     register int i,j;
  2258.     char *imagefile=NULL;
  2259.     IMAGE *image;
  2260.     FILE *fp;
  2261.     
  2262.     stdopts(&argc,argv);
  2263.     if (argc-1>=1)
  2264.         imagefile= *++argv;
  2265.  
  2266.     if (imagefile==NULL)
  2267.         fp=stdin;
  2268.     else if (!(fp=fopen(imagefile,"r"))) {
  2269.         fprintf(stderr,"Cannot open %s\n",imagefile);
  2270.         exit(-1);
  2271.         }
  2272.  
  2273.     image=readimage(fp);
  2274.  
  2275.     if (!newtitle)
  2276.         strcat(image->title," | invert");
  2277.     else
  2278.         strcpy(image->title,newtitle);
  2279.  
  2280.     for(j=0;j<image->ysize;j++)
  2281.         for(i=0;i<image->xsize;i++)
  2282.             image->image[j][i]=abs(255 - image->image[j][i]);
  2283.  
  2284.  
  2285.     writeimage(stdout,image);
  2286.     fclose(fp);
  2287. }
  2288. End of invert.c
  2289.  echo lap1 1>&2
  2290. cat >lap1 <<'End of lap1'
  2291. 3 3
  2292.  
  2293.  0 -1  0
  2294. -1  4 -1
  2295.  0 -1  0
  2296. End of lap1
  2297.  echo normalise.c 1>&2
  2298. cat >normalise.c <<'End of normalise.c'
  2299. #include <stdio.h>
  2300. #include "image.h"
  2301.  
  2302. #define GREYLEVELS     256
  2303.  
  2304. IMAGE *image;
  2305.  
  2306. main(argc, argv)
  2307. char **argv;
  2308. {
  2309.  
  2310.     int c, low= -1, high= -1;
  2311.     char buff[BUFSIZ];
  2312.     register int i,j;
  2313.     char *imagefile = NULL;
  2314.     FILE *fp;
  2315.  
  2316.     stdopts(&argc, argv);
  2317.  
  2318.     imagefile = (*argv++)?*argv:NULL;
  2319.  
  2320.     if (imagefile == NULL)
  2321.         fp = stdin;
  2322.     else if (!(fp = fopen(imagefile, "r"))) {
  2323.         fprintf(stderr, "Cannot open %s\n", imagefile);
  2324.         exit(-1);
  2325.     }
  2326.  
  2327.     image = readimage(fp);
  2328.  
  2329.     if (!newtitle)
  2330.         strcat(image->title," | normalise");
  2331.     else
  2332.         strcpy(image->title,newtitle);
  2333.  
  2334.     norm(image);
  2335.  
  2336.     writeimage(stdout,image);
  2337. }
  2338.  
  2339. norm(image)
  2340. IMAGE *image;
  2341. {
  2342.     register int i,j;
  2343.     int x;
  2344.     int totpix=image->xsize * image->ysize;
  2345.     int hist[GREYLEVELS][2];
  2346.     int sum;
  2347.  
  2348.     for (i = 0; i < GREYLEVELS; i++) 
  2349.         hist[i][0] = hist[i][1] = 0;
  2350.  
  2351.     for (j=0;j<image->ysize;j++)
  2352.         for (i=0;i<image->xsize;i++) 
  2353.             hist[image->image[j][i]][0]++;
  2354.  
  2355.     sum = 0;
  2356.     for (i = 0; i < GREYLEVELS; i++) {
  2357.         sum += hist[i][0];
  2358.         x = sum * GREYLEVELS/ totpix;
  2359.         x = (x > 255) ? 255 : x;
  2360.         hist[i][1] = x;
  2361.     }
  2362.  
  2363.     for(j=0;j<image->ysize;j++)
  2364.         for(i=0;i<image->xsize;i++)
  2365.             image->image[j][i]=hist[image->image[j][i]][1];
  2366. }
  2367. End of normalise.c
  2368.  echo pattern3.h 1>&2
  2369. cat >pattern3.h <<'End of pattern3.h'
  2370. /* file pattern.h */
  2371. int pat[] = 
  2372. {    0,0,0,
  2373.     0,0,0,
  2374.     0,0,0,
  2375.         0,0,0,
  2376.         0,1,0,
  2377.         0,0,0,
  2378.     0,0,0,
  2379.     1,0,1,
  2380.     0,0,0,
  2381.         0,0,1,
  2382.         0,1,0,
  2383.         1,0,0,
  2384.     0,1,0,
  2385.     1,0,1,
  2386.     0,1,0,
  2387.         1,0,1,
  2388.         0,1,0,
  2389.         1,0,1,
  2390.     1,1,1,
  2391.     0,1,0,
  2392.     1,0,1,
  2393.         1,1,1,
  2394.         1,1,0,
  2395.         1,0,1,
  2396.     1,1,1,
  2397.     1,0,1,
  2398.     1,1,1,
  2399.         1,1,1,
  2400.         1,1,1,
  2401.         1,1,1};
  2402. End of pattern3.h
  2403.  echo pixval.c 1>&2
  2404. cat >pixval.c <<'End of pixval.c'
  2405. #include <stdio.h>
  2406. #include <string.h>
  2407. #include "image.h"
  2408.  
  2409. IMAGE *image,
  2410.       *image1;
  2411.  
  2412. main (argc,argv)
  2413. int argc;
  2414. char **argv;
  2415. {
  2416.     register int i,j;
  2417.     char *imagefile=NULL;
  2418.     FILE *fp;
  2419.  
  2420.     stdopts(&argc,argv);
  2421.     windopts(&argc,argv);
  2422.  
  2423.     if (argc>1)
  2424.         imagefile = argv[1];
  2425.  
  2426.     if (imagefile==NULL)
  2427.         fp=stdin;
  2428.     else if (!(fp=fopen(imagefile,"r"))) {
  2429.         fprintf(stderr,"Cannot open %s\n",imagefile);
  2430.         exit(-1);
  2431.         }
  2432.  
  2433.     image=readimage(fp);
  2434.     image1=newimage(winxsize,winysize,"");
  2435.  
  2436.     subarea(image,image1,winxoff,winyoff);
  2437.     
  2438.     for (j=0;j<image1->ysize;j++) {
  2439.         for(i=0;i<image1->xsize;i++)
  2440.             printf("%4d",image1->image[j][i]);
  2441.         putchar('\n');
  2442.         }
  2443. }
  2444. End of pixval.c
  2445.  echo range.c 1>&2
  2446. cat >range.c <<'End of range.c'
  2447. #include <stdio.h>
  2448. #include "image.h"
  2449.  
  2450. IMAGE *image;
  2451.  
  2452. main(argc, argv)
  2453. char **argv;
  2454. {
  2455.  
  2456.     int c, low= 0, high= 255;
  2457.     char buff[BUFSIZ];
  2458.     register int i,j;
  2459.     char *imagefile = NULL;
  2460.     FILE *fp;
  2461.  
  2462.     stdopts(&argc, argv);
  2463.  
  2464.     for (argv++; *argv; *argv++)
  2465.         if (**argv == '-')
  2466.             switch ((*argv)[1]) {
  2467.             case 'l':
  2468.                 low = atoi(argv[0] + 2);
  2469.                 break;
  2470.             case 'h':
  2471.                 high = atoi(argv[0] + 2);
  2472.                 break;
  2473.             }
  2474.         else
  2475.             imagefile = *argv;
  2476.  
  2477.     if (imagefile == NULL)
  2478.         fp = stdin;
  2479.     else if (!(fp = fopen(imagefile, "r"))) {
  2480.         fprintf(stderr, "Cannot open %s\n", imagefile);
  2481.         exit(-1);
  2482.     }
  2483.  
  2484.     image = readimage(fp);
  2485.  
  2486.     if (!newtitle)
  2487.     {
  2488.         strcat(image->title," | range");
  2489.         sprintf(buff," -l%d",low);
  2490.         strcat(image->title,buff);
  2491.         sprintf(buff," -h%d",high);
  2492.         strcat(image->title,buff);
  2493.     }
  2494.     else
  2495.         strcpy(image->title,newtitle);
  2496.  
  2497.     for(j=0;j<image->ysize;j++)
  2498.         for(i=0;i<image->xsize;i++) {
  2499.             c = (image->image[j][i] - low) * 255 / (high - low);
  2500.             c = (c < 0) ? 0 : c;
  2501.             image->image[j][i]= (c > 255) ? 255 : c;
  2502.             }
  2503.  
  2504.     writeimage(stdout,image);
  2505. }
  2506. End of range.c
  2507.  echo retitle.c 1>&2
  2508. cat >retitle.c <<'End of retitle.c'
  2509. #include <stdio.h>
  2510. #include "image.h"
  2511.  
  2512. main(argc,argv)
  2513. char **argv;
  2514. {
  2515. IMAGE *image1,*image2;
  2516. FILE *fp;
  2517.  
  2518.     stdopts(&argc,argv);
  2519.     if (helpflag)
  2520.     {
  2521.         help(*argv);
  2522.         exit(0);
  2523.     }
  2524.     if (argc>1)
  2525.     {
  2526.         if (!(fp=fopen(argv[1],"r")))
  2527.         {
  2528.             fprintf(stderr,"%s: cannot open %s\n",argv[0],argv[1]);
  2529.             exit(-1);
  2530.         }
  2531.         image1=readimage(fp);
  2532.     }
  2533.     else
  2534.         image1=readimage(stdin);
  2535.  
  2536.     if (newtitle)
  2537.     {
  2538.         image2=newimage(image1->xsize,image1->ysize,newtitle);
  2539.         image2->image=image1->image;
  2540.         writeimage(stdout,image2);
  2541.     }
  2542.     else
  2543.         writeimage(stdout,image1);
  2544. }
  2545.  
  2546. help(name)
  2547. char *name;
  2548. {
  2549.     printf("Retitling Filter\n");
  2550.     printf("----------------\n");
  2551.     printf("\nUsage: %s [file]\n",name);
  2552.     printf("\nOptions:\n");
  2553.     printf("  -h      help\n");
  2554.     printf("  -ttitle new title\n");
  2555. }
  2556. End of retitle.c
  2557.  echo sobel1 1>&2
  2558. cat >sobel1 <<'End of sobel1'
  2559. 5 5
  2560.  
  2561.  1  2  0 -2 -1
  2562.  2  4  0 -4 -2
  2563.  2  6  0 -6 -2
  2564.  2  4  0 -4 -2
  2565.  1  2  0 -2 -1
  2566.  
  2567.  
  2568. End of sobel1
  2569.  echo striphead.c 1>&2
  2570. cat >striphead.c <<'End of striphead.c'
  2571. #include <stdio.h>
  2572. #include "image.h"
  2573.  
  2574. IMAGE *image;
  2575.  
  2576. main(argc,argv)
  2577. int argc;
  2578. char **argv;
  2579. {
  2580.     int i,j;
  2581.     int xsize,ysize;
  2582.     unsigned char **pic;
  2583.     char *file, *title;
  2584.     FILE *fp;
  2585.  
  2586.     stdopts(&argc,argv);
  2587.  
  2588.     file = (*argv++)?*argv:NULL;
  2589.  
  2590.     if (file==NULL) {
  2591.         if (!(fp=fopen(file,"r"))) {
  2592.             fprintf(stderr,"Cannot open %s\n",file);
  2593.             exit(-1);
  2594.             }
  2595.         }
  2596.     else fp=stdin;
  2597.  
  2598.     image=readimage(fp);
  2599.  
  2600.     for (j=0;j<image->ysize;j++)
  2601.         for (i=0;i<image->xsize;i++)
  2602.             putchar(image->image[j][i]);
  2603.  
  2604.     fclose(fp);
  2605. }
  2606. End of striphead.c
  2607.  echo subarea.c 1>&2
  2608. cat >subarea.c <<'End of subarea.c'
  2609. #include <stdio.h>
  2610. #include "image.h"
  2611.  
  2612. main(argc,argv)
  2613. char **argv;
  2614. {
  2615. FILE *fp;
  2616.  
  2617.     stdopts(&argc,argv);
  2618.     windopts(&argc,argv);
  2619.  
  2620.     if (helpflag)
  2621.     {
  2622.         help(*argv);
  2623.         exit(0);
  2624.     }
  2625.     if (argc<1)
  2626.     {
  2627.         fprintf(stderr,"Usage: %s [filename]\n",argv[0]);
  2628.         exit(-1);
  2629.     }
  2630.     if (winxoff<0 || winyoff<0 || winxsize<0 || winysize<0)
  2631.     {
  2632.         fprintf(stderr,"Negative Values not permitted !!\n");
  2633.         exit(-1);
  2634.     }
  2635.     if (argc==1)
  2636.         subar(stdin);
  2637.     else
  2638.         if (!(fp=fopen(argv[1],"r")))
  2639.         {
  2640.             fprintf(stderr,"%s: cannot open %s\n",argv[0],argv[1]);
  2641.             exit(-1);
  2642.         }
  2643.         else
  2644.         {
  2645.             subar(fp);
  2646.             fclose(fp);
  2647.         }
  2648. }
  2649.  
  2650. subar(fp)
  2651. FILE *fp;
  2652. {
  2653. IMAGE *image1,*image2;
  2654.  
  2655.     image1=readimage(fp);
  2656.  
  2657.     if (newtitle)
  2658.         image2=newimage(winxsize,winysize,newtitle);
  2659.     else
  2660.     {
  2661.         image2=newimage(winxsize,winysize,image1->title);
  2662.         strcat(image2->title," | subarea");
  2663.     }
  2664.  
  2665.     subarea(image1,image2,winxoff,winyoff);
  2666.  
  2667.     writeimage(stdout,image2);
  2668. }
  2669.  
  2670. help(name)
  2671. char *name;
  2672. {
  2673.     printf("Subsample Filter\n");
  2674.     printf("----------------\n");
  2675.     printf("\nUsage: %s -xn -yn -Xn -Yn [file]\n",name);
  2676.     printf("\nOptions:\n");
  2677.     printf("  -h      help\n");
  2678.     printf("  -ttitle new title\n");
  2679. }
  2680. End of subarea.c
  2681.  echo subsample.c 1>&2
  2682. cat >subsample.c <<'End of subsample.c'
  2683. #include <stdio.h>
  2684. #include "image.h"
  2685.  
  2686. main(argc,argv)
  2687. char **argv;
  2688. {
  2689. int newx,newy;
  2690. FILE *fp;
  2691.  
  2692.     stdopts(&argc,argv);
  2693.     if (helpflag)
  2694.     {
  2695.         help(*argv);
  2696.         exit(0);
  2697.     }
  2698.     if (argc<3)
  2699.     {
  2700.         fprintf(stderr,"Usage: %s newx newy [filename]\n",argv[0]);
  2701.         exit(-1);
  2702.     }
  2703.     newx=atoi(argv[1]);
  2704.     newy=atoi(argv[2]);
  2705.     if (newx<=0 || newy<=0)
  2706.     {
  2707.         fprintf(stderr,"Negative Values not permitted !!\n");
  2708.         exit(-1);
  2709.     }
  2710.     if (argc==3)
  2711.         subsamp(stdin,newx,newy);
  2712.     else
  2713.         if (!(fp=fopen(argv[3],"r")))
  2714.         {
  2715.             fprintf(stderr,"%s: cannot open %s\n",argv[0],argv[3]);
  2716.             exit(-1);
  2717.         }
  2718.         else
  2719.         {
  2720.             subsamp(fp,newx,newy);
  2721.             fclose(fp);
  2722.         }
  2723. }
  2724.  
  2725. subsamp(fp,x,y)
  2726. FILE *fp;
  2727. {
  2728. IMAGE *image1,*image2;
  2729.  
  2730.     image1=readimage(fp);
  2731.  
  2732.     if (newtitle)
  2733.         image2=newimage(x,y,newtitle);
  2734.     else
  2735.     {
  2736.         image2=newimage(x,y,image1->title);
  2737.         strcat(image2->title," | subsample");
  2738.     }
  2739.  
  2740.     subsample(image1,image2);
  2741.  
  2742.     writeimage(stdout,image2);
  2743. }
  2744.  
  2745. help(name)
  2746. char *name;
  2747. {
  2748.     printf("Subsample Filter\n");
  2749.     printf("----------------\n");
  2750.     printf("\nUsage: %s xsize ysize [file]\n",name);
  2751.     printf("\nOptions:\n");
  2752.     printf("  -h      help\n");
  2753.     printf("  -ttitle new title\n");
  2754. }
  2755. End of subsample.c
  2756.  echo thresh.c 1>&2
  2757. cat >thresh.c <<'End of thresh.c'
  2758. #include <math.h>
  2759. #include <stdio.h>
  2760. #include "image.h"
  2761.  
  2762. #define MAX 255
  2763. #define MIN 0
  2764. main(argc, argv)
  2765. int argc;
  2766. char **argv;
  2767. {
  2768.     register int i,j;
  2769.     char buff[BUFSIZ];
  2770.     int thresh;
  2771.     FILE *fp;
  2772.     IMAGE *image, *image2;
  2773.  
  2774.     stdopts(&argc,argv);
  2775.  
  2776.     if (argc>1 && argv[1][0]=='-' && argv[1][1]=='t')
  2777.         thresh = atoi(argv[1]+2);
  2778.     else
  2779.         thresh = -1;
  2780.     
  2781.     for (*argv++;*argv;argv++)
  2782.         if (**argv!='-')
  2783.             break;
  2784.  
  2785.     if (*argv)
  2786.     {
  2787.         if (!(fp=fopen(*argv,"r")))
  2788.         {
  2789.             fprintf(stderr,"Cannot Open %s\n",*argv);
  2790.             exit(-1);
  2791.         }
  2792.     }
  2793.     else
  2794.         fp=stdin;
  2795.  
  2796.     image=readimage(fp);
  2797.     fclose(fp);
  2798.     image2=newimage(image->xsize,image->ysize,(newtitle)?newtitle:image->title);
  2799.  
  2800.     if (!newtitle)
  2801.     {
  2802.         strcat(image2->title," | thresh");
  2803.         if (thresh >= 0) {
  2804.             sprintf(buff," -t%d",thresh);
  2805.             strcat(image2->title,buff); 
  2806.         }
  2807.     }
  2808.     else strcpy(image2->title,newtitle);
  2809.     
  2810.     if (thresh == -1)
  2811.         thresh=autothresh(image);
  2812.  
  2813.     for (j=0;j<image->ysize;j++)
  2814.         for (i=0;i<image->xsize;i++)
  2815.             image2->image[j][i]=image->image[j][i]<thresh?MIN:MAX;
  2816.  
  2817.     writeimage(stdout,image2);
  2818. }
  2819.  
  2820. autothresh(image)
  2821. IMAGE *image;
  2822. {
  2823.     register int x, y;
  2824.     int mean, sumx = 0, sumxsqrd = 0;
  2825.     double sd, nsd = 1.5;
  2826.  
  2827.     for (y = 0; y < image->ysize; y++) 
  2828.         for (x = 0; x < image->xsize; x++) {
  2829.             sumx += image->image[y][x];
  2830.             sumxsqrd += image->image[y][x] * image->image[y][x];
  2831.         }
  2832.  
  2833.     mean = sumx / (image->xsize * image->ysize);
  2834.     sd = sqrt((double) sumxsqrd / (image->xsize * image->ysize) - (mean * mean));
  2835.     x=nsd*sd;
  2836.     fprintf(stderr,"Threshold = %d\n",(int)(mean + x /* (nsd * sd)*/));
  2837.     return (int)(mean + x /*(nsd * sd)*/);
  2838. }
  2839. End of thresh.c
  2840.  echo xdiff1 1>&2
  2841. cat >xdiff1 <<'End of xdiff1'
  2842. 7 7
  2843.  
  2844. 1 1 1 0 -1 -1 -1
  2845. 1 1 1 0 -1 -1 -1
  2846. 1 1 1 0 -1 -1 -1
  2847. 1 1 1 0 -1 -1 -1
  2848. 1 1 1 0 -1 -1 -1
  2849. 1 1 1 0 -1 -1 -1
  2850. 1 1 1 0 -1 -1 -1
  2851. End of xdiff1
  2852.  
  2853.  
  2854.