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