home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume38 / lic / part07 < prev    next >
Text File  |  1993-08-11  |  66KB  |  2,151 lines

  1. Newsgroups: comp.sources.misc
  2. From: casey@gauss.llnl.gov (Casey Leedom)
  3. Subject: v38i110:  lic - LLNL Line Integral Convolution, v1.2, Part07/10
  4. Message-ID: <1993Aug12.013926.14307@sparky.sterling.com>
  5. X-Md4-Signature: 299c0cda33ada3acac503228b6d2f091
  6. Sender: kent@sparky.sterling.com (Kent Landfield)
  7. Organization: Sterling Software
  8. Date: Thu, 12 Aug 1993 01:39:26 GMT
  9. Approved: kent@sparky.sterling.com
  10.  
  11. Submitted-by: casey@gauss.llnl.gov (Casey Leedom)
  12. Posting-number: Volume 38, Issue 110
  13. Archive-name: lic/part07
  14. Environment: UNIX
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # Contents:  lic.1.2/doc/cover.me lic.1.2/liblic/Convolve2D.c
  21. #   lic.1.2/liblic/Convolve3D.c lic.1.2/liblic/LIC.3
  22. #   lic.1.2/liblic/LIC_Create.3 lic.1.2/lic/lic.1
  23. # Wrapped by kent@sparky on Wed Aug 11 19:38:06 1993
  24. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 7 (of 10)."'
  27. if test -f 'lic.1.2/doc/cover.me' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'lic.1.2/doc/cover.me'\"
  29. else
  30.   echo shar: Extracting \"'lic.1.2/doc/cover.me'\" \(6455 characters\)
  31.   sed "s/^X//" >'lic.1.2/doc/cover.me' <<'END_OF_FILE'
  32. X.\" Copyright (c) 1993 The Regents of the University of California.
  33. X.\" All rights reserved.
  34. X.\"
  35. X.\" Redistribution and use in source and binary forms, with or without
  36. X.\" modification, are permitted provided that the following conditions
  37. X.\" are met:
  38. X.\" 1. Redistributions of source code must retain the above copyright
  39. X.\"    notice, this list of conditions and the following disclaimer.
  40. X.\" 2. Redistributions in binary form must reproduce the above copyright
  41. X.\"    notice, this list of conditions and the following disclaimer in the
  42. X.\"    documentation and/or other materials provided with the distribution.
  43. X.\" 3. All advertising materials mentioning features or use of this software
  44. X.\"    must display the following acknowledgement:
  45. X.\"    This product includes software developed by the University of
  46. X.\"    California, Lawrence Livermore National Laboratory and its
  47. X.\"    contributors.
  48. X.\" 4. Neither the name of the University nor the names of its contributors
  49. X.\"    may be used to endorse or promote products derived from this software
  50. X.\"    without specific prior written permission.
  51. X.\"
  52. X.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  53. X.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  54. X.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  55. X.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  56. X.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  57. X.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  58. X.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  59. X.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  60. X.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  61. X.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  62. X.\" SUCH DAMAGE.
  63. X.\"
  64. X.po 1.0in
  65. X.ll 6.5in
  66. X.nr pi 0n
  67. X.de Hd
  68. X.ds Vr 1.2
  69. X.ds Dt \\$4
  70. X..
  71. X.Hd $Header: /d/sisal/a/casey/tmp/lic/doc/RCS/cover.me,v 1.5 1993/07/27 01:24:18 casey Exp $
  72. X.of '\*(Dt''LLNL LIC version \*(Vr'
  73. X.ef '\*(Dt''LLNL LIC version \*(Vr'
  74. X.(b C
  75. X.sz +10
  76. X.rs
  77. X.sp 2.25in
  78. XLLNL
  79. X.sp .25in
  80. XLine Integral Convolution
  81. X.sp .5in
  82. XDistribution
  83. X.sp 2in
  84. XVersion \*(Vr
  85. X\*(Dt
  86. X.sz -10
  87. X.)b
  88. X.\" We delay defining the footer so it won't show up on the first page ...
  89. X.of 'LLNL LIC version \*(Vr''\*(Dt'
  90. X.ef '\*(Dt''LLNL LIC version \*(Vr'
  91. X.pa
  92. X.rs
  93. X.sp 3.75in
  94. XCopyright (c) 1993 The Regents of the University of California.
  95. XAll rights reserved.
  96. X.pp
  97. XRedistribution and use in source and binary forms, with or without
  98. Xmodification, are permitted provided that the following conditions
  99. Xare met:
  100. X.ip 1.
  101. XRedistributions of source code must retain the above copyright
  102. Xnotice, this list of conditions and the following disclaimer.
  103. X.ip 2.
  104. XRedistributions in binary form must reproduce the above copyright
  105. Xnotice, this list of conditions and the following disclaimer in the
  106. Xdocumentation and/or other materials provided with the distribution.
  107. X.ip 3.
  108. XAll advertising materials mentioning features or use of this software
  109. Xmust display the following acknowledgement:
  110. X.(q
  111. XThis product includes software developed by the University of
  112. XCalifornia, Lawrence Livermore National Laboratory and its contributors.
  113. X.)q
  114. X.ip 4.
  115. XNeither the name of the University nor the names of its contributors
  116. Xmay be used to endorse or promote products derived from this software
  117. Xwithout specific prior written permission.
  118. X.pp
  119. XTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  120. XANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  121. XIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  122. XARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  123. XFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  124. XDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  125. XOR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  126. XHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  127. XLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  128. XOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  129. XSUCH DAMAGE.
  130. X.pa
  131. X.(b C
  132. X.sz +2
  133. XContents
  134. X.sz -2
  135. X.)b
  136. X.sp 3v
  137. X.(x i
  138. XIntroduction
  139. X.)x 1
  140. X.(x i
  141. XREADME
  142. X.)x 2
  143. X.(x i
  144. XABSTRACT
  145. X.)x 3
  146. X.(x i
  147. XMEMO
  148. X.)x 4
  149. X.(x i
  150. XTODO
  151. X.)x 5
  152. X.(x i
  153. XImaging Vector Fields Using Line Integral Convolution
  154. X.)x 6
  155. X.(x i
  156. XManual pages
  157. X.)x 7
  158. X.(x i
  159. XInclude file sources
  160. X.)x 8
  161. X.(x i
  162. Xlic command source
  163. X.)x 9
  164. X.(x i
  165. XLIC AVS coroutine module source
  166. X.)x 10
  167. X.(x i
  168. XLIC library sources
  169. X.)x 11
  170. X.xp i
  171. X.pa
  172. X.(b C
  173. X.sz +2
  174. X1
  175. X.sp 1v
  176. XIntroduction
  177. X.sz -2
  178. X.)b
  179. X.sp 3v
  180. X.pp
  181. XThis document contains the documentation and source code to the LLNL
  182. XLine Integral Convolution (LIC) software distribution version \*(Vr.
  183. X.pp
  184. XThe LLNL LIC software is an experimental implementation of a new
  185. Xvector visualization algorithm.  It allows researchers to experiment
  186. Xwith this algorithm and duplicate results presented in the paper
  187. X.i "Imaging Vector Fields Using Line Integral Convolution"
  188. Xby Brian Cabral and Casey Leedom in the 1993 SIGGRAPH conference.
  189. X.pp
  190. XThe software consists of an object-oriented library that implements
  191. Xthe algorithm, a command line interface and an AVS interface and
  192. Xdocumentation for all of the above.
  193. X.pa
  194. X.(b C
  195. X.sz +2
  196. X2
  197. X.sp 1v
  198. XREADME
  199. X.sz -2
  200. X.)b
  201. X.pa
  202. X.(b C
  203. X.sz +2
  204. X3
  205. X.sp 1v
  206. XABSTRACT
  207. X.sz -2
  208. X.)b
  209. X.pa
  210. X.(b C
  211. X.sz +2
  212. X4
  213. X.sp 1v
  214. XMEMO
  215. X.sz -2
  216. X.)b
  217. X.pa
  218. X.(b C
  219. X.sz +2
  220. X5
  221. X.sp 1v
  222. XTODO
  223. X.sz -2
  224. X.)b
  225. X.pa
  226. X.(b C
  227. X.sz +2
  228. X6
  229. X.sp 1v
  230. XImaging Vector Fields Using Line Integral Convolution
  231. X.sz -2
  232. X.)b
  233. X.pa
  234. X.(b C
  235. X.sz +2
  236. X7
  237. X.sp 1v
  238. XManual pages
  239. X.sz -2
  240. X.)b
  241. X.sp 3v
  242. X.pp
  243. X.(x i
  244. Xlic.1
  245. X.)x 1
  246. X.(x i
  247. XLIC.txt (AVS coroutine on-line documentation)
  248. X.)x 2
  249. X.(x i
  250. XLIC.3
  251. X.)x 3
  252. X.(x i
  253. XLIC_ComputeImage.3
  254. X.)x 4
  255. X.(x i
  256. XLIC_Convolve.3
  257. X.)x 5
  258. X.(x i
  259. XLIC_Create.3
  260. X.)x 6
  261. X.(x i
  262. XLIC_Destroy.3
  263. X.)x 7
  264. X.(x i
  265. XLIC_Filters.3
  266. X.)x 8
  267. X.(x i
  268. XLIC_Modify.3
  269. X.)x 9
  270. X.(x i
  271. XLIC_Query.3
  272. X.)x 10
  273. X.xp i
  274. X.pa
  275. X.(b C
  276. X.sz +2
  277. X8
  278. X.sp 1v
  279. XInclude file sources
  280. X.sz -2
  281. X.)b
  282. X.sp 3v
  283. X.pp
  284. X.(x i
  285. Xinclude/lic.h
  286. X.)x 1
  287. X.xp i
  288. X.pa
  289. X.(b C
  290. X.sz +2
  291. X9
  292. X.sp 1v
  293. Xlic command source
  294. X.sz -2
  295. X.)b
  296. X.sp 3v
  297. X.(x i
  298. Xlic/lic.c
  299. X.)x 1
  300. X.xp i
  301. X.pa
  302. X.(b C
  303. X.sz +2
  304. X10
  305. X.sp 1v
  306. XLIC AVS coroutine module source
  307. X.sz -2
  308. X.)b
  309. X.sp 3v
  310. X.pp
  311. X.(x i
  312. Xavs/LIC.c
  313. X.)x 1
  314. X.xp i
  315. X.pa
  316. X.(b C
  317. X.sz +2
  318. X11
  319. X.sp 1v
  320. XLIC library sources
  321. X.sz -2
  322. X.)b
  323. X.sp 3v
  324. X.pp
  325. X.(x i
  326. Xliblic.h
  327. X.)x 1
  328. X.(x i
  329. XComputeImage.c
  330. X.)x 2
  331. X.(x i
  332. XConvolve2D.c
  333. X.)x 3
  334. X.(x i
  335. XConvolve3D.c
  336. X.)x 4
  337. X.(x i
  338. XCreate.c
  339. X.)x 5
  340. X.(x i
  341. XDestroy.c
  342. X.)x 6
  343. X.(x i
  344. XFilters.c
  345. X.)x 7
  346. X.(x i
  347. XModify.c
  348. X.)x 8
  349. X.(x i
  350. XQuery.c
  351. X.)x 9
  352. X.xp i
  353. END_OF_FILE
  354.   if test 6455 -ne `wc -c <'lic.1.2/doc/cover.me'`; then
  355.     echo shar: \"'lic.1.2/doc/cover.me'\" unpacked with wrong size!
  356.   fi
  357.   # end of 'lic.1.2/doc/cover.me'
  358. fi
  359. if test -f 'lic.1.2/liblic/Convolve2D.c' -a "${1}" != "-c" ; then 
  360.   echo shar: Will not clobber existing file \"'lic.1.2/liblic/Convolve2D.c'\"
  361. else
  362.   echo shar: Extracting \"'lic.1.2/liblic/Convolve2D.c'\" \(9707 characters\)
  363.   sed "s/^X//" >'lic.1.2/liblic/Convolve2D.c' <<'END_OF_FILE'
  364. X/*
  365. X * $Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/Convolve2D.c,v 1.7 1993/08/10 23:35:32 casey Exp $
  366. X */
  367. X
  368. X/*
  369. X * Copyright (c) 1993 The Regents of the University of California.
  370. X * All rights reserved.
  371. X *
  372. X * Redistribution and use in source and binary forms, with or without
  373. X * modification, are permitted provided that the following conditions
  374. X * are met:
  375. X * 1. Redistributions of source code must retain the above copyright
  376. X *    notice, this list of conditions and the following disclaimer.
  377. X * 2. Redistributions in binary form must reproduce the above copyright
  378. X *    notice, this list of conditions and the following disclaimer in the
  379. X *    documentation and/or other materials provided with the distribution.
  380. X * 3. All advertising materials mentioning features or use of this software
  381. X *    must display the following acknowledgement:
  382. X *    This product includes software developed by the University of
  383. X *    California, Lawrence Livermore National Laboratory and its
  384. X *    contributors.
  385. X * 4. Neither the name of the University nor the names of its contributors
  386. X *    may be used to endorse or promote products derived from this software
  387. X *    without specific prior written permission.
  388. X *
  389. X * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  390. X * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  391. X * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  392. X * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  393. X * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  394. X * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  395. X * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  396. X * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  397. X * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  398. X * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  399. X * SUCH DAMAGE.
  400. X */
  401. X
  402. X#ifndef lint
  403. X    static char rcsid[] = "$Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/Convolve2D.c,v 1.7 1993/08/10 23:35:32 casey Exp $";
  404. X    static char copyright[] =
  405. X    "Copyright (c) 1993 The Regents of the University of California.\n"
  406. X    "All rights reserved.\n";
  407. X#endif
  408. X
  409. X
  410. X#include "liblic.h"
  411. X
  412. X
  413. X/*
  414. X *    Two-dimensional Line Integral Convolution.
  415. X *    ============================================
  416. X */
  417. X
  418. X
  419. X#ifdef DEBUG
  420. Xextern FILE *ps;
  421. X#endif
  422. X
  423. X
  424. Xvoid
  425. XLIC_Convolve2D(LIC      *This,
  426. X           int       i,
  427. X           int       j,
  428. X           int       direction,
  429. X           double   *rIntegral,
  430. X           double   *gIntegral,
  431. X           double   *bIntegral,
  432. X           double   *aIntegral,
  433. X           double   *KernelArea)
  434. X    /*
  435. X     * Perform Line Integral Convolution on a two-dimensional vector field.
  436. X     */
  437. X{
  438. X    REGISTER double L;            /* pos/neg length of kernel */
  439. X    REGISTER double s, sp;        /* parametric distance along kernel */
  440. X    double          wp;            /* integral corresponding to sp */
  441. X    double          rSum, gSum,        /* integrated pixel values */
  442. X            bSum, aSum;
  443. X    int             speed;        /* integral table speed index */
  444. X    double         *itab, is;        /* integral table and index scale */
  445. X    int             LoopCount;        /* main loop iteration count */
  446. X
  447. X    sp = 0.0;
  448. X
  449. X    rSum = 0.0;
  450. X    gSum = 0.0;
  451. X    bSum = 0.0;
  452. X    aSum = 0.0;
  453. X
  454. X    /*
  455. X     * Establish length, L, of convolution and which ``speed'' version of the
  456. X     * filter kernel to use.  The default L is the value set by the user.
  457. X     * For VariableLength convolutions, L is scaled by the magnitude of the
  458. X     * vector.  The default speed is to use the maximum ``speed'' version of
  459. X     * the filter kernel.  For VariableSpeed convolutions, speed is scaled
  460. X     * by the magnitude of the vector.
  461. X     */
  462. X    L = LIC_Length(This);
  463. X    speed = LIC_INTEGRAL_SPEEDS - 1;
  464. X    if (This->VariableLength || This->VariableSpeed)
  465. X    {
  466. X    REGISTER double fx, fy, norm;
  467. X
  468. X    fx = INDEX_2D(This->InputField, i, j)[0];
  469. X    fy = INDEX_2D(This->InputField, i, j)[1];
  470. X    norm = sqrt(fx*fx + fy*fy) / This->MaxLength;
  471. X
  472. X    if (This->VariableLength)
  473. X        L *= norm;
  474. X    if (This->VariableSpeed)
  475. X        speed *= norm;
  476. X    }
  477. X
  478. X    /*
  479. X     * Establish filter kernel integral table to use based on direction and
  480. X     * speed.  Also determine index scaling for values of s, 0 <= s <= L,
  481. X     * into the table.  Note that the scaling is performed relative to L,
  482. X     * not LIC_Length(This).  Scaling relative to L means that the filter
  483. X     * is effectively dilated to match the convolution length even when
  484. X     * performing VariableLength convolution.
  485. X     */
  486. X    if (This->NeedIntegration)
  487. X    LIC_BuildIntegralTables(This);
  488. X    if (direction == LIC_FOREWARD)
  489. X    itab = &This->PosIntegralTable[speed][0];
  490. X    else
  491. X    itab = &This->NegIntegralTable[speed][0];
  492. X    is = (double)(LIC_INTEGRAL_LEN - 1) / L;
  493. X
  494. X    LoopCount = 0;
  495. X
  496. X#   ifdef DEBUG
  497. X    if (ThisPixel)
  498. X        fprintf(ps, "0.0 0.0 moveto\n");
  499. X#   endif
  500. X
  501. X    /*
  502. X     * Only perform LIC if L is greater than zero.  Zero lengths
  503. X     * can result from bad user input or magnitude based lengths.
  504. X     */
  505. X    if (L > 0)
  506. X    {
  507. X    REGISTER int    fi, fj;        /* vector field index */
  508. X    REGISTER double x, y;        /* current cartesian location in the */
  509. X                    /*   vector field */
  510. X
  511. X    fi = i;
  512. X    fj = j;
  513. X
  514. X    x =  i + 0.5;
  515. X    y = This->NormalField.Yres - j - 0.5;
  516. X
  517. X    wp = 0.0;
  518. X
  519. X    /* Loop until we reach the end of the line integral */
  520. X    do
  521. X    {
  522. X        REGISTER double t;        /* distance to nearest cell edge */
  523. X        REGISTER double fx, fy;    /* vector field values */
  524. X
  525. X        /*
  526. X         * Grab the current cell vector.
  527. X         */
  528. X
  529. X        /* Get the field value for this cell */
  530. X        fx = INDEX_2D(This->NormalField, fi, fj)[0];
  531. X        fy = INDEX_2D(This->NormalField, fi, fj)[1];
  532. X
  533. X        /* Bail out if the vector field goes to zero */
  534. X        if (fx == 0.0 && fy == 0.0)
  535. X        break;
  536. X
  537. X        if (direction == LIC_BACKWARD)
  538. X        {
  539. X        fx = -fx;
  540. X        fy = -fy;
  541. X        }
  542. X
  543. X        /*
  544. X         * Compute the intersection with the next cell along the line
  545. X         * of the vector field.
  546. X         */
  547. X        {
  548. X        REGISTER double tt;
  549. X#        define TT(v) \
  550. X        { \
  551. X            tt = (v); \
  552. X            if (tt < t) \
  553. X            t = tt; \
  554. X        }
  555. X
  556. X        if (fx < -SIN_PARALLEL)
  557. X            t = (FLOOR(x) - x) / fx;        /* left edge */
  558. X        else if (fx > SIN_PARALLEL)
  559. X            t = (CEIL(x) - x) / fx;        /* right edge */
  560. X        else
  561. X            t = HUGE_VAL;
  562. X
  563. X        if (fy < -SIN_PARALLEL)
  564. X            TT((FLOOR(y) - y) / fy)        /* bottom edge */
  565. X        else if (fy > SIN_PARALLEL)
  566. X            TT((CEIL(y) - y) / fy)        /* top edge */
  567. X
  568. X#        undef TT
  569. X        }
  570. X
  571. X        /* s and sp represent a monotonically moving convolution window */
  572. X        s  = sp;
  573. X        sp = sp + t;
  574. X        t += ROUND_OFF;
  575. X
  576. X        /* Make sure we don't exceed the kernel width */
  577. X        if (sp > L)
  578. X        {
  579. X        sp = L;
  580. X        t  =  sp - s;
  581. X        }
  582. X
  583. X#        ifdef DEBUG
  584. X        if (ThisPixel)
  585. X            fprintf(ps, "%f %f rlineto\n", fx*t, fy*t);
  586. X#        endif
  587. X
  588. X        /*
  589. X         * Grab the input pixel corresponding to the current cell and
  590. X         * integrate its value over the convolution kernel from s to sp.
  591. X         */
  592. X        {
  593. X#        if (PixelSize >= 3)
  594. X            double rV, gV, bV;
  595. X#        endif
  596. X#        if (PixelSize == 4 || PixelSize == 1)
  597. X            double aV;
  598. X#        endif
  599. X        {
  600. X            REGISTER int ii, ij;
  601. X
  602. X            /* toriodally wrap input image coordinates */
  603. X            ii = fi;
  604. X            ij = fj;
  605. X            WRAP(ii, This->InputImage.Xres);
  606. X            WRAP(ij, This->InputImage.Yres);
  607. X
  608. X            /* Get the input image value for this cell */
  609. X#            if (PixelSize >= 3)
  610. X            rV = RED  (INDEX_2D(This->InputImage, ii, ij));
  611. X            gV = GREEN(INDEX_2D(This->InputImage, ii, ij));
  612. X            bV = BLUE (INDEX_2D(This->InputImage, ii, ij));
  613. X#            endif
  614. X#            if (PixelSize == 4 || PixelSize == 1)
  615. X            aV = ALPHA(INDEX_2D(This->InputImage, ii, ij));
  616. X#            endif
  617. X        }
  618. X
  619. X        /* integrate over the convolution kernel between s and sp */
  620. X        {
  621. X            double          wt;
  622. X            REGISTER double dw;
  623. X
  624. X            wt = itab[(int)(sp * is)];
  625. X            dw = wt - wp;
  626. X            wp = wt;
  627. X
  628. X#            if (PixelSize >= 3)
  629. X            rSum  += (rV * dw);
  630. X            gSum  += (gV * dw);
  631. X            bSum  += (bV * dw);
  632. X#            endif
  633. X#            if (PixelSize == 4 || PixelSize == 1)
  634. X            aSum  += (aV * dw);
  635. X#            endif
  636. X        }
  637. X        }
  638. X
  639. X        /*
  640. X         * March to the next cell.
  641. X         */
  642. X
  643. X        LoopCount++;
  644. X
  645. X        /* Compute the cell we just stepped into */
  646. X        x = x + fx*t;
  647. X        y = y + fy*t;
  648. X
  649. X        /* break out of the loop if we step out of the field */
  650. X        if (x < 0.0 || y < 0.0)
  651. X            break;
  652. X
  653. X        fi = IFLOOR(x);
  654. X        fj = This->NormalField.Yres - ICEIL(y);
  655. X
  656. X        /* Break out of the loop if we step out of the field */
  657. X        if (   fi >= This->NormalField.Xres
  658. X        || fj < 0)
  659. X        break;
  660. X
  661. X        /*
  662. X         * Loop until we reach the end or we think we've fallen into
  663. X         * a singularity.
  664. X         */
  665. X    } while (sp < L && LoopCount <= 3*L);
  666. X    }
  667. X
  668. X    if (LoopCount > 0 && L > 0)
  669. X    {
  670. X    *rIntegral = rSum;
  671. X    *gIntegral = gSum;
  672. X    *bIntegral = bSum;
  673. X    *aIntegral = aSum;
  674. X
  675. X    /* Compute an integration normalization factor as function of sp */
  676. X    *KernelArea = (This->NormalizationType == LIC_VARIABLE)
  677. X        ? wp
  678. X        : itab[LIC_INTEGRAL_LEN - 1];
  679. X    }
  680. X    else
  681. X    {
  682. X#    if (PixelSize >= 3)
  683. X        *rIntegral = (This->DefaultRed == -1)
  684. X        ? RED  (INDEX_2D(This->InputImage, i, j))
  685. X        : (double)This->DefaultRed;
  686. X        *gIntegral = (This->DefaultGreen == -1)
  687. X        ? GREEN(INDEX_2D(This->InputImage, i, j))
  688. X        : (double)This->DefaultGreen;
  689. X        *bIntegral = (This->DefaultBlue == -1)
  690. X        ? BLUE (INDEX_2D(This->InputImage, i, j))
  691. X        : (double)This->DefaultBlue;
  692. X#    else
  693. X        *rIntegral = 0.0;
  694. X        *gIntegral = 0.0;
  695. X        *bIntegral = 0.0;
  696. X#    endif
  697. X#    if (PixelSize == 4 || PixelSize == 1)
  698. X        *aIntegral = (This->DefaultAlpha == -1)
  699. X        ? ALPHA(INDEX_2D(This->InputImage, i, j))
  700. X        : (double)This->DefaultAlpha;
  701. X#    else
  702. X        *aIntegral = 0.0;
  703. X#    endif
  704. X
  705. X    *KernelArea = 1;
  706. X    }
  707. X
  708. X    /*
  709. X     * Random bookkeeping for performance monitoring.
  710. X     */
  711. X    This->TotalLoopCount += LoopCount;
  712. X    This->TotalLength    += sp;
  713. X}
  714. END_OF_FILE
  715.   if test 9707 -ne `wc -c <'lic.1.2/liblic/Convolve2D.c'`; then
  716.     echo shar: \"'lic.1.2/liblic/Convolve2D.c'\" unpacked with wrong size!
  717.   fi
  718.   # end of 'lic.1.2/liblic/Convolve2D.c'
  719. fi
  720. if test -f 'lic.1.2/liblic/Convolve3D.c' -a "${1}" != "-c" ; then 
  721.   echo shar: Will not clobber existing file \"'lic.1.2/liblic/Convolve3D.c'\"
  722. else
  723.   echo shar: Extracting \"'lic.1.2/liblic/Convolve3D.c'\" \(10020 characters\)
  724.   sed "s/^X//" >'lic.1.2/liblic/Convolve3D.c' <<'END_OF_FILE'
  725. X/*
  726. X * $Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/Convolve3D.c,v 1.6 1993/08/10 23:35:32 casey Exp $
  727. X */
  728. X
  729. X/*
  730. X * Copyright (c) 1993 The Regents of the University of California.
  731. X * All rights reserved.
  732. X *
  733. X * Redistribution and use in source and binary forms, with or without
  734. X * modification, are permitted provided that the following conditions
  735. X * are met:
  736. X * 1. Redistributions of source code must retain the above copyright
  737. X *    notice, this list of conditions and the following disclaimer.
  738. X * 2. Redistributions in binary form must reproduce the above copyright
  739. X *    notice, this list of conditions and the following disclaimer in the
  740. X *    documentation and/or other materials provided with the distribution.
  741. X * 3. All advertising materials mentioning features or use of this software
  742. X *    must display the following acknowledgement:
  743. X *    This product includes software developed by the University of
  744. X *    California, Lawrence Livermore National Laboratory and its
  745. X *    contributors.
  746. X * 4. Neither the name of the University nor the names of its contributors
  747. X *    may be used to endorse or promote products derived from this software
  748. X *    without specific prior written permission.
  749. X *
  750. X * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  751. X * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  752. X * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  753. X * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  754. X * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  755. X * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  756. X * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  757. X * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  758. X * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  759. X * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  760. X * SUCH DAMAGE.
  761. X */
  762. X
  763. X#ifndef lint
  764. X    static char rcsid[] = "$Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/Convolve3D.c,v 1.6 1993/08/10 23:35:32 casey Exp $";
  765. X    static char copyright[] =
  766. X    "Copyright (c) 1993 The Regents of the University of California.\n"
  767. X    "All rights reserved.\n";
  768. X#endif
  769. X
  770. X
  771. X#include "liblic.h"
  772. X
  773. X
  774. X/*
  775. X *    Three-dimensional Line Integral Convolution.
  776. X *    ============================================
  777. X */
  778. X
  779. X
  780. Xvoid
  781. XLIC_Convolve3D(LIC      *This,
  782. X           int       i,
  783. X           int       j,
  784. X           int       k,
  785. X           int       direction,
  786. X           double   *rIntegral,
  787. X           double   *gIntegral,
  788. X           double   *bIntegral,
  789. X           double   *aIntegral,
  790. X           double   *KernelArea)
  791. X    /*
  792. X     * Perform Line Integral Convolution on a three-dimensional vector field.
  793. X     */
  794. X{
  795. X    REGISTER double L;            /* pos/neg length of kernel */
  796. X    REGISTER double s, sp;        /* parametric distance along kernel */
  797. X    double          wp;            /* integral corresponding to sp */
  798. X    double          rSum, gSum,        /* integrated pixel values */
  799. X            bSum, aSum;
  800. X    int             speed;        /* integral table speed index */
  801. X    double         *itab, is;        /* integral table and index scale */
  802. X    int             LoopCount;        /* main loop iteration count */
  803. X
  804. X    sp = 0.0;
  805. X
  806. X    rSum = 0.0;
  807. X    gSum = 0.0;
  808. X    bSum = 0.0;
  809. X    aSum = 0.0;
  810. X
  811. X    /*
  812. X     * Establish length, L, of convolution and which ``speed'' version of the
  813. X     * filter kernel to use.  The default L is the value set by the user.
  814. X     * For VariableLength convolutions, L is scaled by the magnitude of the
  815. X     * vector.  The default speed is to use the maximum ``speed'' version of
  816. X     * the filter kernel.  For VariableSpeed convolutions, speed is scaled
  817. X     * by the magnitude of the vector.
  818. X     */
  819. X    L = LIC_Length(This);
  820. X    speed = LIC_INTEGRAL_SPEEDS - 1;
  821. X    if (This->VariableLength || This->VariableSpeed)
  822. X    {
  823. X    REGISTER double fx, fy, fz, norm;
  824. X
  825. X    fx = INDEX_3D(This->InputField, i, j, k)[0];
  826. X    fy = INDEX_3D(This->InputField, i, j, k)[1];
  827. X    fz = INDEX_3D(This->InputField, i, j, k)[2];
  828. X    norm = sqrt(fx*fx + fy*fy + fz*fz) / This->MaxLength;
  829. X
  830. X    if (This->VariableLength)
  831. X        L *= norm;
  832. X    if (This->VariableSpeed)
  833. X        speed *= norm;
  834. X    }
  835. X
  836. X    /*
  837. X     * Establish filter kernel integral table to use based on direction and
  838. X     * speed.  Also determine index scaling for values of s, 0 <= s <= L,
  839. X     * into the table.  Note that the scaling is performed relative to L,
  840. X     * not LIC_Length(This).  Scaling relative to L means that the filter
  841. X     * is effectively dilated to match the convolution length even when
  842. X     * performing VariableLength convolution.
  843. X     */
  844. X    if (This->NeedIntegration)
  845. X    LIC_BuildIntegralTables(This);
  846. X    if (direction == LIC_FOREWARD)
  847. X    itab = &This->PosIntegralTable[speed][0];
  848. X    else
  849. X    itab = &This->NegIntegralTable[speed][0];
  850. X    is = (double)(LIC_INTEGRAL_LEN - 1) / L;
  851. X
  852. X    LoopCount = 0;
  853. X
  854. X    /*
  855. X     * Only perform LIC if L is greater than zero.  Zero lengths
  856. X     * can result from bad user input or magnitude based lengths.
  857. X     */
  858. X    if (L > 0)
  859. X    {
  860. X    REGISTER int    fi, fj, fk;    /* vector field indices */
  861. X    REGISTER double x, y, z;    /* current cartesian location in the */
  862. X                    /*   vector field */
  863. X
  864. X    fi = i;
  865. X    fj = j;
  866. X    fk = k;
  867. X
  868. X    x = i + 0.5;
  869. X    y = This->NormalField.Yres - j - 0.5;
  870. X    z = k + 0.5;
  871. X
  872. X    wp = 0.0;
  873. X
  874. X    /* Loop until we reach the end of the line integral */
  875. X    do
  876. X    {
  877. X        REGISTER double t;        /* distance to nearest cell face */
  878. X        REGISTER double fx, fy, fz;    /* vector field values */
  879. X
  880. X        /*
  881. X         * Grab the current cell vector.
  882. X         */
  883. X
  884. X        /* Get the field value in This pixel */
  885. X        fx = INDEX_3D(This->NormalField, fi, fj, fk)[0];
  886. X        fy = INDEX_3D(This->NormalField, fi, fj, fk)[1];
  887. X        fz = INDEX_3D(This->NormalField, fi, fj, fk)[2];
  888. X
  889. X        /* bail out if the vector field goes to zero */
  890. X        if (fx == 0.0 && fy == 0.0 && fz == 0.0)
  891. X        break;
  892. X
  893. X        if (direction == LIC_BACKWARD)
  894. X        {
  895. X        fx = -fx;
  896. X        fy = -fy;
  897. X        fz = -fz;
  898. X        }
  899. X
  900. X        /*
  901. X         * Compute the intersection with the next cell along the line
  902. X         * of the vector field.
  903. X         */
  904. X        {
  905. X        REGISTER double tt;
  906. X#        define TT(v) \
  907. X        { \
  908. X            tt = (v); \
  909. X            if (tt < t) \
  910. X            t = tt; \
  911. X        }
  912. X
  913. X        if (fx < -SIN_PARALLEL)
  914. X            t = (FLOOR(x) - x) / fx;        /* left face */
  915. X        else if (fx > SIN_PARALLEL)
  916. X            t = (CEIL(x) - x) / fx;        /* right face */
  917. X        else
  918. X            t = HUGE_VAL;
  919. X
  920. X        if (fy < -SIN_PARALLEL)
  921. X            TT((FLOOR(y) - y) / fy)        /* bottom face */
  922. X        else if (fy > SIN_PARALLEL)
  923. X            TT((CEIL(y) - y) / fy)        /* top face */
  924. X
  925. X        if (fz < -SIN_PARALLEL)
  926. X            TT((FLOOR(z) - z) / fz)        /* front face */
  927. X        else if (fz > SIN_PARALLEL)
  928. X            TT((CEIL(z) - z) / fz)        /* back face */
  929. X
  930. X#        undef TT
  931. X        }
  932. X
  933. X        /* s and sp represent a monotonically moving convolution window */
  934. X        s  = sp;
  935. X        sp = sp + t;
  936. X        t += ROUND_OFF;
  937. X
  938. X        /* Make sure we don't exceed the kernel width */
  939. X        if (sp > L)
  940. X        {
  941. X        sp = L;
  942. X        t  =  sp - s;
  943. X        }
  944. X
  945. X        /*
  946. X         * Grab the input pixel corresponding to the current cell and
  947. X         * integrate its value over the convolution kernel from s to sp.
  948. X         */
  949. X        {
  950. X#        if (PixelSize >= 3)
  951. X            double rV, gV, bV;
  952. X#        endif
  953. X#        if (PixelSize == 4 || PixelSize == 1)
  954. X            double aV;
  955. X#        endif
  956. X        {
  957. X            REGISTER int ii, ij, ik;
  958. X
  959. X            /* toriodally wrap input image coordinates */
  960. X            ii = fi;
  961. X            ij = fj;
  962. X            ik = fk;
  963. X            WRAP(ii, This->InputImage.Xres);
  964. X            WRAP(ij, This->InputImage.Yres);
  965. X            WRAP(ik, This->InputImage.Zres);
  966. X
  967. X            /* Get the input image value for this cell */
  968. X#            if (PixelSize >= 3)
  969. X            rV = RED  (INDEX_3D(This->InputImage, ii, ij, ik));
  970. X            gV = GREEN(INDEX_3D(This->InputImage, ii, ij, ik));
  971. X            bV = BLUE (INDEX_3D(This->InputImage, ii, ij, ik));
  972. X#            endif
  973. X#            if (PixelSize == 4 || PixelSize == 1)
  974. X            aV = ALPHA(INDEX_3D(This->InputImage, ii, ij, ik));
  975. X#            endif
  976. X        }
  977. X
  978. X        /* integrate over the convolution kernel between s and sp */
  979. X        {
  980. X            double          wt;
  981. X            REGISTER double dw;
  982. X
  983. X            wt = itab[(int)(sp * is)];
  984. X            dw = wt - wp;
  985. X            wp = wt;
  986. X
  987. X#            if (PixelSize >= 3)
  988. X            rSum  += (rV * dw);
  989. X            gSum  += (gV * dw);
  990. X            bSum  += (bV * dw);
  991. X#            endif
  992. X#            if (PixelSize == 4 || PixelSize == 1)
  993. X            aSum  += (aV * dw);
  994. X#            endif
  995. X        }
  996. X        }
  997. X
  998. X        /*
  999. X         * March to the next cell.
  1000. X         */
  1001. X
  1002. X        LoopCount++;
  1003. X
  1004. X        /* Compute the cell we just stepped into */
  1005. X        x = x + fx*t;
  1006. X        y = y + fy*t;
  1007. X        z = z + fz*t;
  1008. X
  1009. X        /* break out of the loop if we step out of the field */
  1010. X        if (x < 0.0 || y < 0.0 || z < 0.0)
  1011. X            break;
  1012. X
  1013. X        fi = IFLOOR(x);
  1014. X        fj = This->NormalField.Yres - ICEIL(y);
  1015. X        fk = IFLOOR(z);
  1016. X
  1017. X        /* break out of the loop if we step out of the field */
  1018. X        if (   fi >= This->NormalField.Xres
  1019. X        || fj < 0
  1020. X        || fk >= This->NormalField.Zres)
  1021. X        break;
  1022. X
  1023. X        /*
  1024. X         * Loop until we reach the end or we think we've fallen into
  1025. X         * a singularity.
  1026. X         */
  1027. X    } while (sp < L && LoopCount <= 3*L);
  1028. X    }
  1029. X
  1030. X    if (LoopCount > 0 && L > 0)
  1031. X    {
  1032. X    *rIntegral = rSum;
  1033. X    *gIntegral = gSum;
  1034. X    *bIntegral = bSum;
  1035. X    *aIntegral = aSum;
  1036. X
  1037. X    /* Compute an integration normalization factor as function of sp */
  1038. X    *KernelArea = (This->NormalizationType == LIC_VARIABLE)
  1039. X        ? wp
  1040. X        : itab[LIC_INTEGRAL_LEN - 1];
  1041. X    }
  1042. X    else
  1043. X    {
  1044. X#    if (PixelSize >= 3)
  1045. X        *rIntegral = (This->DefaultRed == -1)
  1046. X        ? RED  (INDEX_3D(This->InputImage, i, j, k))
  1047. X        : (double)This->DefaultRed;
  1048. X        *gIntegral = (This->DefaultGreen == -1)
  1049. X        ? GREEN(INDEX_3D(This->InputImage, i, j, k))
  1050. X        : (double)This->DefaultGreen;
  1051. X        *bIntegral = (This->DefaultBlue == -1)
  1052. X        ? BLUE (INDEX_3D(This->InputImage, i, j, k))
  1053. X        : (double)This->DefaultBlue;
  1054. X#    else
  1055. X        *rIntegral = 0.0;
  1056. X        *gIntegral = 0.0;
  1057. X        *bIntegral = 0.0;
  1058. X#    endif
  1059. X#    if (PixelSize == 4 || PixelSize == 1)
  1060. X        *aIntegral = (This->DefaultAlpha == -1)
  1061. X        ? ALPHA(INDEX_3D(This->InputImage, i, j, k))
  1062. X        : (double)This->DefaultAlpha;
  1063. X#    else
  1064. X        *aIntegral = 0.0;
  1065. X#    endif
  1066. X
  1067. X    *KernelArea = 1;
  1068. X    }
  1069. X
  1070. X    /*
  1071. X     * Random bookkeeping for performance monitoring.
  1072. X     */
  1073. X    This->TotalLoopCount += LoopCount;
  1074. X    This->TotalLength    += sp;
  1075. X}
  1076. END_OF_FILE
  1077.   if test 10020 -ne `wc -c <'lic.1.2/liblic/Convolve3D.c'`; then
  1078.     echo shar: \"'lic.1.2/liblic/Convolve3D.c'\" unpacked with wrong size!
  1079.   fi
  1080.   # end of 'lic.1.2/liblic/Convolve3D.c'
  1081. fi
  1082. if test -f 'lic.1.2/liblic/LIC.3' -a "${1}" != "-c" ; then 
  1083.   echo shar: Will not clobber existing file \"'lic.1.2/liblic/LIC.3'\"
  1084. else
  1085.   echo shar: Extracting \"'lic.1.2/liblic/LIC.3'\" \(11842 characters\)
  1086.   sed "s/^X//" >'lic.1.2/liblic/LIC.3' <<'END_OF_FILE'
  1087. X.\" Copyright (c) 1993 The Regents of the University of California.
  1088. X.\" All rights reserved.
  1089. X.\"
  1090. X.\" Redistribution and use in source and binary forms, with or without
  1091. X.\" modification, are permitted provided that the following conditions
  1092. X.\" are met:
  1093. X.\" 1. Redistributions of source code must retain the above copyright
  1094. X.\"    notice, this list of conditions and the following disclaimer.
  1095. X.\" 2. Redistributions in binary form must reproduce the above copyright
  1096. X.\"    notice, this list of conditions and the following disclaimer in the
  1097. X.\"    documentation and/or other materials provided with the distribution.
  1098. X.\" 3. All advertising materials mentioning features or use of this software
  1099. X.\"    must display the following acknowledgement:
  1100. X.\"    This product includes software developed by the University of
  1101. X.\"    California, Lawrence Livermore National Laboratory and its
  1102. X.\"    contributors.
  1103. X.\" 4. Neither the name of the University nor the names of its contributors
  1104. X.\"    may be used to endorse or promote products derived from this software
  1105. X.\"    without specific prior written permission.
  1106. X.\"
  1107. X.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  1108. X.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  1109. X.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  1110. X.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  1111. X.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  1112. X.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  1113. X.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  1114. X.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  1115. X.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  1116. X.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  1117. X.\" SUCH DAMAGE.
  1118. X.\"
  1119. X.de Hd
  1120. X.ds Dt \\$4
  1121. X..
  1122. X.Hd $Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/LIC.3,v 1.5 1993/07/30 21:01:03 casey Exp $
  1123. X.TH LIC 3 \*(Dt
  1124. X.SH NAME
  1125. Xlic \- Line Integral Convolution library
  1126. X.SH SYNOPSIS
  1127. X.nf
  1128. X#include <lic.h>
  1129. X
  1130. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1131. XLIC *\fBLIC_Create\fP(unsigned char    *\fIInputImage\fP,
  1132. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1133. X    int        \fIiiXres\fP,
  1134. X    int        \fIiiYres\fP,
  1135. X    int        \fIiiZres\fP,
  1136. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1137. X    float    *\fIInputField\fP,
  1138. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1139. X    int        \fIifXres\fP,
  1140. X    int        \fIifYres\fP,
  1141. X    int        \fIifZres\fP,
  1142. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1143. X    unsigned char    *\fIOutputImage\fP,
  1144. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1145. X    LIC_Filter    \fIFilter\fP,
  1146. X    int        \fINormalizationType\fP,
  1147. X    int        \fINormalized\fP,
  1148. X    double    \fILength\fP,
  1149. X    double    \fIFrequency\fP,
  1150. X    int        \fIVariableLength\fP,
  1151. X    int        \fIVariableSpeed\fP,
  1152. X    int    \fIDefaultRed\fP,
  1153. X    int    \fIDefaultGreen\fP,
  1154. X    int    \fIDefaultBlue\fP,
  1155. X    int    \fIDefaultAlpha\fP,
  1156. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX'u
  1157. X    void        (*\fIUpdateUser\fP)(double),
  1158. X    void        (*\fIReportError\fP)(const char *))
  1159. X.DT
  1160. X
  1161. Xvoid \fBLIC_Destroy\fP(LIC *\fIThis\fP)
  1162. X
  1163. Xvoid \fBLIC_ChangeLength\fP(LIC *\fIThis\fP, double \fIlength\fP)
  1164. Xvoid \fBLIC_ChangeFrequency\fP(LIC *\fIThis\fP, double \fIfrequency\fP);
  1165. Xvoid \fBLIC_ChangePhase\fP(LIC *\fIThis\fP, double \fIphase\fP)
  1166. Xvoid \fBLIC_ChangeFilter\fP(LIC *\fIThis\fP, LIC_Filter \fIfilter\fP)
  1167. X
  1168. Xvoid \fBLIC_BuildIntegralTables\fP(LIC *\fIThis\fP)
  1169. Xdouble \fBLIC_Box\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1170. Xdouble \fBLIC_Ripple\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1171. Xdouble \fBLIC_Ramp\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1172. Xdouble \fBLIC_Select\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1173. X
  1174. Xvoid \fBLIC_ComputeImage\fP(LIC *\fIThis\fP)
  1175. X
  1176. X.ta \w'LIC *\fBLIC_Convolve2D\fP('u +\w'doubleXXX'u
  1177. Xvoid \fBLIC_Convolve2D\fP(LIC    *\fIThis\fP,
  1178. X.ta \w'LIC *\fBLIC_Convolve2D\fP('u +\w'doubleXXX*'u
  1179. X    int    \fIi\fP,
  1180. X    int    \fIj\fP,
  1181. X    int    \fIdirection\fP,
  1182. X.ta \w'LIC *\fBLIC_Convolve2D\fP('u +\w'doubleXXX'u
  1183. X    double    *\fIrIntegral\fP,
  1184. X    double    *\fIgIntegral\fP,
  1185. X    double    *\fIbIntegral\fP,
  1186. X    double    *\fIaIntegral\fP,
  1187. X    double    *\fIKernelArea\fP)
  1188. X.DT
  1189. X
  1190. X.ta \w'LIC *\fBLIC_Convolve3D\fP('u +\w'doubleXXX'u
  1191. Xvoid \fBLIC_Convolve3D\fP(LIC    *\fIThis\fP,
  1192. X.ta \w'LIC *\fBLIC_Convolve3D\fP('u +\w'doubleXXX*'u
  1193. X    int    \fIi\fP,
  1194. X    int    \fIj\fP,
  1195. X    int    \fIk\fP,
  1196. X    int    \fIdirection\fP,
  1197. X.ta \w'LIC *\fBLIC_Convolve3D\fP('u +\w'doubleXXX'u
  1198. X    double    *\fIrIntegral\fP,
  1199. X    double    *\fIgIntegral\fP,
  1200. X    double    *\fIbIntegral\fP,
  1201. X    double    *\fIaIntegral\fP,
  1202. X    double    *\fIKernelArea\fP)
  1203. X.DT
  1204. X
  1205. Xunsigned char *\fBLIC_InputImage\fP(LIC *\fIThis\fP)
  1206. Xfloat *\fBLIC_InputField\fP(LIC *\fIThis\fP)
  1207. Xunsigned char *\fBLIC_OutputImage\fP(LIC *\fIThis\fP)
  1208. X
  1209. Xdouble \fBLIC_Length\fP(LIC *\fIThis\fP)
  1210. Xdouble \fBLIC_Phase\fP(LIC *\fIThis\fP)
  1211. Xdouble \fBLIC_Frequency\fP(LIC *\fIThis\fP)
  1212. X
  1213. Xchar *\fBLIC_ConfiguredPixelType\fP(void)
  1214. Xint \fBLIC_ConfiguredPixelSize\fP(void)
  1215. X.fi
  1216. X.SH DESCRIPTION
  1217. X.B LIC
  1218. Xis the
  1219. X.I "Line Integral Convolution"
  1220. Xlibrary.  Line Integral Convolution is designed for vector field
  1221. Xvisualization but has applications in a number of other domains including
  1222. Ximage processing and special effects.
  1223. X.PP
  1224. XVectors are visualized by convolving an input image along vector
  1225. Xstream lines in an input vector field.  The result is an output image that
  1226. Xlooks like the input image, but blurred in the directions of the
  1227. Xvector field.
  1228. X.PP
  1229. XThe convolution is performed for each vector field element as
  1230. Xfollows: a parametric curve in the vector field is created by
  1231. Xlocally following the vector field forward and backward for some
  1232. Xdistance,
  1233. X.IR L .
  1234. XThe parametric curve is laid over the corresponding
  1235. Xinput image pixels.  This yields a pixel value function, \fIF\fP(\fIs\fP),
  1236. Xon the parametric curve.  \fIF\fP(\fIs\fP) is convolved with a filter kernel,
  1237. X\fIk\fP(\fIs\fP), to produce the Line Integral Convolution output:
  1238. X.PP
  1239. X.RS
  1240. Xintegral { \fIF\fP(\fIs\fP) * \fIk\fP(\fIs\fP) \fIds\fP }
  1241. X.RE
  1242. X.PP
  1243. XThe convolution sum is usually normalized by the area of the convolution
  1244. Xfilter in order to maintain the average brightness levels of the input
  1245. Ximage:
  1246. X.PP
  1247. X.RS
  1248. Xintegral { \fIF\fP(\fIs\fP) * \fIk\fP(\fIs\fP) \fIds\fP }
  1249. X/ integral { \fIk\fP(\fIs\fP) \fIds\fP }
  1250. X.RE
  1251. X.PP
  1252. XDepending on the shape of the filter kernel, the input image, the
  1253. Xinput vector field and several control parameters, a wide variety of
  1254. Xresults can be obtained.  These can range from the look of hair
  1255. Xfollowing vector field lines to melting surfaces to artificial motion
  1256. Xblur to periodic motion animations.
  1257. X.PP
  1258. XFor an in depth description of Line Integral Convolution see the paper
  1259. X.I "Imaging vector Fields Using Line Integral Convolution"
  1260. Xby Brian Cabral and Casey Leedom in the 1993 SIGGRAPH proceedings.
  1261. X.PP
  1262. XAll following information refers to the implementation of
  1263. XLine Integral Convolution in this software package.  This manual page
  1264. Xcorresponds to version 1.2 of the
  1265. X.B LIC
  1266. Xlibrary.
  1267. X.PP
  1268. XThe library software is object oriented in flavor (but is implemented
  1269. Xin ANSI C).  The general pattern of usage is to create a LIC object instance
  1270. Xvia
  1271. X.BR LIC_Create (3),
  1272. Xto modify various features of the instance via methods described in
  1273. X.BR LIC_Modify (3)
  1274. Xand then to call
  1275. X.BR LIC_ComputeImage (3)
  1276. Xto have the Line Integral Convolution performed.  When all is said and
  1277. Xdone, a call to
  1278. X.BR LIC_Destroy (3)
  1279. Xwill free up any resources used by the LIC instance.
  1280. X.PP
  1281. XFor more detailed information, see the manual pages for the individual
  1282. Xmethods.
  1283. X.SH COMPATIBILITY
  1284. XThis is experimental software.  In general, it is not compatible with
  1285. Xany other software system.  However, there is an AVS coroutine module
  1286. Xavailable which is compatible with other AVS modules.
  1287. X.PP
  1288. XSince the software is not part of the stock system software, some
  1289. Xeffort will probably be necessary to use it.  Typically this will
  1290. Xentail compiling your source with flags something like
  1291. X.RI -I/ usr / local / include
  1292. Xand linking your program with flags
  1293. X.RI -L/ usr / local / lib
  1294. Xand
  1295. X.RI -l lic .
  1296. XInstallations will differ from machine to machine and some installations
  1297. Xmay not require anything special to access the 
  1298. X.B LIC
  1299. Xsoftware.
  1300. X.SH PORTABILITY
  1301. XThis software has been written to conform to ANSI C as
  1302. Xdefined in
  1303. X.I "ANSI X3.159-1989"
  1304. Xand
  1305. XPOSIX 1003.1 as defined in
  1306. X.IR "IEEE Std 1003.1-1990" .
  1307. XEvery effort has been made to make the software portable under those
  1308. Xguidelines.  There has been no effort whatsoever to make the software
  1309. Xusable under the obsolete K&R C definition.  C++ compatibility is
  1310. Xbelieved to be working, but has not been tested.
  1311. X.PP
  1312. XAs of this writing, the
  1313. X.B LIC
  1314. Xsoftware has been ported to DEC Alphas running OSF1, HP Snakes running
  1315. XHP-UX 8.07, IBM RS/6000s running AIX 3.2, SGI R3000/R4000s running
  1316. XIRIX 4.0.5 and Sun Sparcs running SunOS 4.1.1.
  1317. X.SH "RETURN VALUES"
  1318. XSee manual pages for individual functions and commands for details on
  1319. Xreturn values.
  1320. X.SH ERRORS
  1321. XSee manual pages for individual methods and commands for details on
  1322. Xerror handling.
  1323. X.SH "SEE ALSO"
  1324. X.BR lic (1),
  1325. X.BR LIC_ComputeImage (3),
  1326. X.BR LIC_Convolve (3),
  1327. X.BR LIC_Create (3),
  1328. X.BR LIC_Destroy (3),
  1329. X.BR LIC_Filters (3),
  1330. X.BR LIC_Modify (3),
  1331. X.BR LIC_Query (3),
  1332. XAVS coroutine module
  1333. X.B LIC
  1334. X.PP
  1335. X.I "Imaging Vector Fields Using Line Integral Convolution"
  1336. Xby Brian Cabral and Casey Leedom in the SIGGRAPH '93 proceedings.
  1337. X.SH BUGS
  1338. XPixel types and sizes are configured into the LIC software at compile time.
  1339. XOnly single precision vector field ordinate values are supported.  These should
  1340. Xboth be handled dynamically at run time.
  1341. X.PP
  1342. XThere are too many parameters to
  1343. X.BR LIC_Create .
  1344. XThere are also simultaneously too few and too many \fBLIC_Change\fP\fIFoo\fP
  1345. Xroutines.  There are too few because we really want to expose all the LIC
  1346. Xknobs to the user, but there are too many because they're proliferating like
  1347. Xrabbits.  Probably something more along the lines of
  1348. X.B XtVaSetArgs
  1349. Xis what we really want.
  1350. X.SH STANDARDS
  1351. XThis is unsupported, non-standard software.  It is not the subject of any
  1352. Xstandards effort.
  1353. X.SH COPYRIGHT
  1354. XCopyright (c) 1993 The Regents of the University of California.
  1355. XAll rights reserved.
  1356. X.PP
  1357. XRedistribution and use in source and binary forms, with or without
  1358. Xmodification, are permitted provided that the following conditions
  1359. Xare met:
  1360. X.TP 4
  1361. X1.
  1362. XRedistributions of source code must retain the above copyright
  1363. Xnotice, this list of conditions and the following disclaimer.
  1364. X.TP 4
  1365. X2.
  1366. XRedistributions in binary form must reproduce the above copyright
  1367. Xnotice, this list of conditions and the following disclaimer in the
  1368. Xdocumentation and/or other materials provided with the distribution.
  1369. X.TP 4
  1370. X3.
  1371. XAll advertising materials mentioning features or use of this software
  1372. Xmust display the following acknowledgement:
  1373. X.PP
  1374. X.RS 8
  1375. XThis product includes software developed by the University of
  1376. XCalifornia, Lawrence Livermore National Laboratory and its
  1377. Xcontributors.
  1378. X.RE
  1379. X.TP 4
  1380. X4.
  1381. XNeither the name of the University nor the names of its contributors
  1382. Xmay be used to endorse or promote products derived from this software
  1383. Xwithout specific prior written permission.
  1384. X.PP
  1385. XTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  1386. XANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  1387. XIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  1388. XARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  1389. XFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  1390. XDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  1391. XOR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  1392. XHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  1393. XLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  1394. XOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  1395. XSUCH DAMAGE.
  1396. END_OF_FILE
  1397.   if test 11842 -ne `wc -c <'lic.1.2/liblic/LIC.3'`; then
  1398.     echo shar: \"'lic.1.2/liblic/LIC.3'\" unpacked with wrong size!
  1399.   fi
  1400.   # end of 'lic.1.2/liblic/LIC.3'
  1401. fi
  1402. if test -f 'lic.1.2/liblic/LIC_Create.3' -a "${1}" != "-c" ; then 
  1403.   echo shar: Will not clobber existing file \"'lic.1.2/liblic/LIC_Create.3'\"
  1404. else
  1405.   echo shar: Extracting \"'lic.1.2/liblic/LIC_Create.3'\" \(11049 characters\)
  1406.   sed "s/^X//" >'lic.1.2/liblic/LIC_Create.3' <<'END_OF_FILE'
  1407. X.\" Copyright (c) 1993 The Regents of the University of California.
  1408. X.\" All rights reserved.
  1409. X.\"
  1410. X.\" Redistribution and use in source and binary forms, with or without
  1411. X.\" modification, are permitted provided that the following conditions
  1412. X.\" are met:
  1413. X.\" 1. Redistributions of source code must retain the above copyright
  1414. X.\"    notice, this list of conditions and the following disclaimer.
  1415. X.\" 2. Redistributions in binary form must reproduce the above copyright
  1416. X.\"    notice, this list of conditions and the following disclaimer in the
  1417. X.\"    documentation and/or other materials provided with the distribution.
  1418. X.\" 3. All advertising materials mentioning features or use of this software
  1419. X.\"    must display the following acknowledgement:
  1420. X.\"    This product includes software developed by the University of
  1421. X.\"    California, Lawrence Livermore National Laboratory and its
  1422. X.\"    contributors.
  1423. X.\" 4. Neither the name of the University nor the names of its contributors
  1424. X.\"    may be used to endorse or promote products derived from this software
  1425. X.\"    without specific prior written permission.
  1426. X.\"
  1427. X.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  1428. X.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  1429. X.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  1430. X.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  1431. X.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  1432. X.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  1433. X.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  1434. X.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  1435. X.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  1436. X.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  1437. X.\" SUCH DAMAGE.
  1438. X.\"
  1439. X.de Hd
  1440. X.ds Dt \\$4
  1441. X..
  1442. X.Hd $Header: /d/sisal/a/casey/tmp/lic/liblic/RCS/LIC_Create.3,v 1.6 1993/07/30 20:00:49 casey Exp $
  1443. X.TH LIC_CREATE 3 \*(Dt
  1444. X.SH NAME
  1445. XLIC_Create \- create Line Integral Convolution object instance
  1446. X.SH SYNOPSIS
  1447. X.nf
  1448. X#include <lic.h>
  1449. X
  1450. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1451. XLIC *\fBLIC_Create\fP(unsigned char    *\fIInputImage\fP,
  1452. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1453. X    int        \fIiiXres\fP,
  1454. X    int        \fIiiYres\fP,
  1455. X    int        \fIiiZres\fP,
  1456. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1457. X    float    *\fIInputField\fP,
  1458. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1459. X    int        \fIifXres\fP,
  1460. X    int        \fIifYres\fP,
  1461. X    int        \fIifZres\fP,
  1462. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX('u
  1463. X    unsigned char    *\fIOutputImage\fP,
  1464. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX(*'u
  1465. X    LIC_Filter    \fIFilter\fP,
  1466. X    int        \fINormalizationType\fP,
  1467. X    int        \fINormalized\fP,
  1468. X    double    \fILength\fP,
  1469. X    double    \fIFrequency\fP,
  1470. X    int        \fIVariableLength\fP,
  1471. X    int        \fIVariableSpeed\fP,
  1472. X    int    \fIDefaultRed\fP,
  1473. X    int    \fIDefaultGreen\fP,
  1474. X    int    \fIDefaultBlue\fP,
  1475. X    int    \fIDefaultAlpha\fP,
  1476. X.ta \w'LIC *\fBLIC_Create\fP('u +\w'unsigned charXXX'u
  1477. X    void        (*\fIUpdateUser\fP)(double \fIpercent-complete\fP),
  1478. X    void        (*\fIReportError\fP)(const char *\fImessage\fP))
  1479. X.DT
  1480. X.fi
  1481. X.SH DESCRIPTION
  1482. X.if t .ds pi \(*p
  1483. X.if n .ds pi Pi
  1484. X.B LIC_Create
  1485. Xconstructs an instance of a LIC object.
  1486. X.PP
  1487. X.I InputImage
  1488. Xis the input image to be convolved,
  1489. X.I InputField
  1490. Xis the input vector field which controls the directional convolution and
  1491. X.I OutputImage
  1492. Xis the output image where Line Integral Convolution results will be placed.
  1493. X.IR iiXres ,
  1494. X.I iiYres
  1495. Xand
  1496. X.I iiZres
  1497. Xare the X, Y and Z sizes of
  1498. X.IR InputImage .
  1499. X.IR ifXres ,
  1500. X.I ifYres
  1501. Xand
  1502. X.I ifZres
  1503. Xare the X, Y and Z sizes of
  1504. X.I InputField
  1505. Xand
  1506. X.IR OutputImage .
  1507. XIf
  1508. X.I InputImage
  1509. Xis smaller than
  1510. X.I InputField
  1511. Xin some dimension, references to
  1512. X.I InputImage
  1513. Xpixels corresponding to
  1514. X.I InputField
  1515. Xcells will be wrapped toriodally.
  1516. XIf
  1517. X.B NULL
  1518. Xis passed for
  1519. X.IR OutputImage ,
  1520. X.B LIC_Create
  1521. Xwill automatically allocate space for it.
  1522. X.PP
  1523. XThe input and output images and input vector field are stored as raw binary
  1524. Xrow major arrays.
  1525. X.PP
  1526. X.I InputImage
  1527. Xand
  1528. X.I OutputImage
  1529. Xare arrays of pixels.  Each pixel is 1 to 4 bytes and must match
  1530. Xthe pixel size configured into the LIC library when it was compiled (see
  1531. X.B LIC_ConfiguredPixelSize
  1532. Xin the
  1533. X.B LIC_Query
  1534. Xmanual page).
  1535. X.PP
  1536. X.I InputField
  1537. Xis an array of single precision floating point vectors. Each vector
  1538. Xis of rank equal to the dimension of the data, 2 for two-dimensional
  1539. Xfields and 3 for three-dimensional fields.  The vectors are stored as
  1540. Xtwo- and three-tuples, respectively, ordered as x-ordinate, y-ordinate
  1541. Xand, if applicable, z-ordinate.
  1542. X.PP
  1543. X.I OutputImage
  1544. Xis created by
  1545. X.BR lic .
  1546. XThe x-y-z size is equal to that of
  1547. X.IR InputField .
  1548. X.PP
  1549. X.I Filter
  1550. Xmust be a pointer to a LIC_Filter type function:
  1551. X.PP
  1552. X.RS
  1553. X.nf
  1554. Xdouble \fIFilter\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1555. X.fi
  1556. X.RE
  1557. X.PP
  1558. X.I Filter
  1559. Xshould return the integral of the filter kernel between
  1560. X.I a
  1561. Xand
  1562. X.IR b .
  1563. X.I speed
  1564. Xspecifies the speed with respect to phase shift animation that
  1565. X.I Filter
  1566. Xshould use for its filter kernel.
  1567. X.I speed
  1568. Xis used to implement the variable speed option (though many filters ignore
  1569. Xthis parameter).
  1570. X.PP
  1571. XThe following filters are supplied with the LIC library:
  1572. X.PP
  1573. X.RS
  1574. X.nf
  1575. Xdouble \fBLIC_Box\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1576. Xdouble \fBLIC_Ripple\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1577. Xdouble \fBLIC_Ramp\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1578. Xdouble \fBLIC_Select\fP(LIC *\fIThis\fP, double \fIa\fP, double \fIb\fP, int \fIspeed\fP)
  1579. X.fi
  1580. X.RE
  1581. X.PP
  1582. XThey implement a box filter, a Hanning windowed Hanning ripple filter,
  1583. Xa ramp filter and a pixel selection filter, respectively.  See
  1584. X.BR LIC_Filters (3)
  1585. Xfor more information on LIC filters and the integration process.
  1586. X.PP
  1587. X.I NormalizationType
  1588. Xspecifies the type of normalization to be used:
  1589. X.B LIC_FIXED
  1590. Xor
  1591. X.BR LIC_VARIABLE .
  1592. XWith fixed normalization, output image pixels will be attenuated near
  1593. Xinput vector field singularities and edges of the input field where
  1594. Xvectors are not parallel to the edges.  With variable normalization,
  1595. Xoutput image pixels will maintain an even brightness level (relative
  1596. Xto the input image pixels they are summed from).
  1597. X.PP
  1598. X.I Normalized
  1599. Xspecifies that the input vector field is normalized: all vectors have
  1600. Xmagnitude 1 or 0.  If the vector field is not normalized, a separate
  1601. Xnormalized copy will be constructed for use in the convolution
  1602. Xmethods.  This may affect the ability to handle large problems because
  1603. Xof memory constraints.  If this becomes a problem, you may want to
  1604. Xconsider pre-normalizing the vector field.  However, this isn't an
  1605. Xoption if you want to do variable length or variable speed convolution
  1606. Xsince the vector magnitudes are used to control the length and speed
  1607. Xvariations (see variable length and variable speed documentation
  1608. Xbelow).
  1609. X.PP
  1610. X.I Length
  1611. Xspecifies the length of the filter kernel.  The filter kernel will actually be
  1612. X.RI 2* Length ,
  1613. Xextending from
  1614. X.RI - Length
  1615. Xto
  1616. X.RI + Length .
  1617. XIt is an error to specify a
  1618. X.I length
  1619. Xless than
  1620. X.BR 0 .
  1621. X.PP
  1622. X.I Frequency
  1623. Xspecifies the frequency of the filter kernel.
  1624. X.I Frequency
  1625. Xis interpreted as the number of cycles of the filter kernel over the domain
  1626. X.RB - \*(pi
  1627. Xto
  1628. X.BR \*(pi .
  1629. X(See
  1630. X.B LIC_ChangePhase
  1631. Xin the
  1632. X.BR LIC_Modify (3)
  1633. Xmanual page for a description of how to change the phase of the filter
  1634. Xkernel.)
  1635. X.I Frequency
  1636. Xis scaled to the length of the filter kernel.  Thus, a
  1637. X.I Frequency
  1638. Xof 2 will cause two repetitions of the filter kernel across the domain
  1639. X.RI - Length
  1640. Xto
  1641. X.RI + Length .
  1642. X.I Frequency
  1643. Xmust be non-zero and positive.
  1644. XCurrently, the only filter supplied with the LIC library that uses this
  1645. Xoption is
  1646. X.BR LIC_Ripple .
  1647. X.PP
  1648. X.I VariableLength
  1649. Xis a boolean flag which, when TRUE, specifies that variable length filtering
  1650. Xshould be performed.  The LIC filter length for each vector \fIv\fP will
  1651. Xvary from 0 to
  1652. X.I Length
  1653. Xbased on the vector's magnitude.  This magnitude scaling is performed
  1654. Xby finding the maximum magnitude vector in the input vector field,
  1655. X\fImax_v\fP, and then using a filter length equal to
  1656. X\fILength\fP  * ||\fIv\fP|| / ||\fImax_v\fP||.
  1657. XThe filter will be dilated to match the length of the convolution.
  1658. XThis prevents any visual artifacts which might occur because of abrupt
  1659. Xfilter truncation if the filter were not dilated.
  1660. X.PP
  1661. X.I VariableSpeed
  1662. Xis a boolean flag which, when TRUE, specifies that variable
  1663. X.I speed
  1664. Xfiltering should be performed.
  1665. XHigh magnitude regions of the vector field will use high
  1666. X.I speed
  1667. Xversions of the filter.  These higher speeds variations are typically
  1668. Xphase multiplied versions of the base phase and are used in periodic
  1669. Xmotion animations to give the appearance of higher speed in higher magnitude
  1670. Xregions of the vector field.
  1671. XHowever, it is up to each filter to implement its own interpretation of
  1672. X.IR speed .
  1673. X.PP
  1674. XFor the ripple filter, the speed variations use a different phase for each
  1675. Xvector
  1676. X.I v
  1677. Xbased on its magnitude.  These phase variations vary from
  1678. X.I Phase
  1679. Xto 3 *
  1680. X.IR Phase .
  1681. X.PP
  1682. XVariable speed filtering is currently only implemented by the ripple
  1683. Xfilter (it doesn't have any effect on the box filter and is of dubious
  1684. Xvalue for the ramp filter.)
  1685. X.PP
  1686. X.IR DefaultRed ,
  1687. X.IR DefaultGreen ,
  1688. X.I DefaultBlue
  1689. Xand
  1690. X.I DefaultAlpha
  1691. Xdefine the default red, green, blue and alpha pixel values to use to represent
  1692. Xzero magnitude vectors.  A value of
  1693. X.B -1
  1694. Xspecifies that the underlaying input image pixel value should be used.
  1695. XFor
  1696. X.B MONOCHROME
  1697. Ximages,
  1698. X.I default-alpha
  1699. Xcontrols the default pixel value.
  1700. X.PP
  1701. X.I UpdateUser
  1702. Xshould be
  1703. X.B NULL
  1704. Xor a pointer to user supplied function.  If
  1705. X.RB non- NULL ,
  1706. Xit will be called by
  1707. X.B LIC_ComputeImage
  1708. Xfrom time to time to report computation progress with a
  1709. X.I percent-complete
  1710. Xvalue between 0.0 and 100.0.
  1711. X.PP
  1712. X.B ReportError
  1713. Xshould be
  1714. X.B NULL
  1715. Xor a pointer to user supplied function.  If
  1716. X.RB non- NULL ,
  1717. Xit will be called by the LIC library routines to report various errors.
  1718. XTypically these will be to report memory allocation failure or errors
  1719. Xin user supplied parameters.  A
  1720. X.B NULL
  1721. Xterminated character string value,
  1722. X.IR message ,
  1723. Xwill be passed to
  1724. X.BR ReportError .
  1725. X.I message
  1726. Xwill not contain a trailing newline.
  1727. X.SH "RETURN VALUES"
  1728. X.B NULL
  1729. Xwill be returned if
  1730. X.B LIC_Create
  1731. Xis unable to allocate memory for the new LIC instance, otherwise a pointer
  1732. Xto the new instance is returned.
  1733. X.SH ERRORS
  1734. XLIC_Create: Unable to allocate memory for LIC instance variable
  1735. X.PP
  1736. XLIC_Create: Unable to allocate memory for normalized input vector field
  1737. X.PP
  1738. XLIC_Create: Unable to allocate memory for output image
  1739. X.SH "SEE ALSO"
  1740. X.BR LIC (3),
  1741. X.BR LIC_Destroy (3),
  1742. X.BR LIC_Modify (3),
  1743. X.BR LIC_Query (3)
  1744. X.SH BUGS
  1745. XIf a negative
  1746. X.I Length
  1747. Xis specified, a length of 0 will be used instead.
  1748. XIf a negative or zero
  1749. X.I Frequency
  1750. Xis specified, a frequency of 1e-6 will be used instead.  In both cases error
  1751. Xmessages should probably be output.
  1752. X.SH STANDARDS
  1753. XThis is unsupported, non-standard software.  It is not the subject of any
  1754. Xstandards effort.
  1755. END_OF_FILE
  1756.   if test 11049 -ne `wc -c <'lic.1.2/liblic/LIC_Create.3'`; then
  1757.     echo shar: \"'lic.1.2/liblic/LIC_Create.3'\" unpacked with wrong size!
  1758.   fi
  1759.   # end of 'lic.1.2/liblic/LIC_Create.3'
  1760. fi
  1761. if test -f 'lic.1.2/lic/lic.1' -a "${1}" != "-c" ; then 
  1762.   echo shar: Will not clobber existing file \"'lic.1.2/lic/lic.1'\"
  1763. else
  1764.   echo shar: Extracting \"'lic.1.2/lic/lic.1'\" \(10950 characters\)
  1765.   sed "s/^X//" >'lic.1.2/lic/lic.1' <<'END_OF_FILE'
  1766. X.\" Copyright (c) 1993 The Regents of the University of California.
  1767. X.\" All rights reserved.
  1768. X.\"
  1769. X.\" Redistribution and use in source and binary forms, with or without
  1770. X.\" modification, are permitted provided that the following conditions
  1771. X.\" are met:
  1772. X.\" 1. Redistributions of source code must retain the above copyright
  1773. X.\"    notice, this list of conditions and the following disclaimer.
  1774. X.\" 2. Redistributions in binary form must reproduce the above copyright
  1775. X.\"    notice, this list of conditions and the following disclaimer in the
  1776. X.\"    documentation and/or other materials provided with the distribution.
  1777. X.\" 3. All advertising materials mentioning features or use of this software
  1778. X.\"    must display the following acknowledgement:
  1779. X.\"    This product includes software developed by the University of
  1780. X.\"    California, Lawrence Livermore National Laboratory and its
  1781. X.\"    contributors.
  1782. X.\" 4. Neither the name of the University nor the names of its contributors
  1783. X.\"    may be used to endorse or promote products derived from this software
  1784. X.\"    without specific prior written permission.
  1785. X.\"
  1786. X.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  1787. X.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  1788. X.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  1789. X.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  1790. X.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  1791. X.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  1792. X.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  1793. X.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  1794. X.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  1795. X.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  1796. X.\" SUCH DAMAGE.
  1797. X.\"
  1798. X.de Hd
  1799. X.ds Dt \\$4
  1800. X..
  1801. X.Hd $Header: /d/sisal/a/casey/tmp/lic/lic/RCS/lic.1,v 1.10 1993/08/10 23:26:52 casey Exp $
  1802. X.TH LIC 1 \*(Dt
  1803. X.SH NAME
  1804. Xlic \- Line Integral Convolution processor
  1805. X.SH SYNOPSIS
  1806. X.nf
  1807. X\fBlic\fP [\fIoptions\fP] \fIinput-image\fP \fIinput-vector-field\fP \fIoutput-image\fP
  1808. X.fi
  1809. X.SH DESCRIPTION
  1810. X.if t .ds pi \(*p
  1811. X.if n .ds pi Pi
  1812. X.B lic
  1813. Xis a command line interface to the
  1814. X.I "Line Integral Convolution"
  1815. Xlibrary.  Line Integral Convolution was designed for vector field
  1816. Xvisualization but has applications in a number of other domains
  1817. Xincluding image processing, special effects and artistic rendering.
  1818. XFor an in depth description of Line Integral Convolution, see
  1819. X.BR LIC (3).
  1820. X.PP
  1821. XThe input and output files are stored as raw binary files without any
  1822. Xheaders.  The files are organized as sequential row major (C-style)
  1823. Xarrays.
  1824. X.PP
  1825. XThe
  1826. X.I input-image
  1827. Xand
  1828. X.I output-image
  1829. Xfiles are arrays of pixels.  Each pixel is 1 to 4 bytes and must match
  1830. Xthe pixel size configured into
  1831. X.B lic
  1832. Xwhen it was compiled (see
  1833. X.B LIC_ConfiguredPixelSize
  1834. Xin the
  1835. X.B LIC_Query
  1836. Xmanual page).
  1837. X.PP
  1838. XThe
  1839. X.I input-vector-field
  1840. Xfile is an array of single precision floating point vectors. Each vector
  1841. Xis of rank equal to the dimension of the data, 2 for two-dimensional
  1842. Xfields and 3 for three-dimensional fields.  The vectors are stored as
  1843. Xtwo- and three-tuples, respectively, ordered as x-coordinate, y-coordinate
  1844. Xand, if applicable, z-coordinate.
  1845. X.PP
  1846. XThe
  1847. X.I output-image
  1848. Xis created by
  1849. X.BR lic .
  1850. XThe x-y-z size of the file is equal to that of the
  1851. X.IR input-vector-field .
  1852. XAs a safety feature
  1853. X.B lic
  1854. Xwill never overwrite an existing file.
  1855. X.PP
  1856. XOptions available are:
  1857. X.PP
  1858. X\fB\-x\fP \fIx-extent\fP (required parameter, \fBno default\fP)
  1859. X.br
  1860. X\fB\-y\fP \fIy-extent\fP (required parameter, \fBno default\fP)
  1861. X.br
  1862. X\fB\-z\fP \fIz-extent\fP (default \fB1\fP)
  1863. X.RS 5
  1864. XSets the
  1865. X.IR x ,
  1866. X.I y
  1867. Xand
  1868. X.I z
  1869. Xsize of
  1870. X.IR input-vector-field .
  1871. XThe
  1872. X.B \-x
  1873. Xand
  1874. X.B \-y
  1875. Xoptions are not optional.  They must be provided.  The
  1876. X.B \-z
  1877. Xis optional and defaults to the value of
  1878. X.BR 1 .
  1879. X.RE
  1880. X.PP
  1881. X\fB\-i\fP \fIi-extent\fP (default \fIx-extent\fP)
  1882. X.br
  1883. X\fB\-j\fP \fIj-extent\fP (default \fIy-extent\fP)
  1884. X.br
  1885. X\fB\-k\fP \fIk-extent\fP (default \fIz-extent\fP)
  1886. X.RS 5
  1887. XSets the
  1888. X.IR x ,
  1889. X.I y
  1890. Xand
  1891. X.I z
  1892. Xsize of
  1893. X.IR input-image .
  1894. XIf not specified, they will default to the same values specified for
  1895. X.IR input-vector-field .
  1896. XThe sizes for
  1897. X.I input-image
  1898. Xand
  1899. X.I input-vector-field
  1900. Xneed not match in any way.  If
  1901. X.I input-image
  1902. Xis smaller than
  1903. X.I input-vector-field
  1904. Xin some dimension, references to
  1905. X.I input-image
  1906. Xpixels corresponding to
  1907. X.I input-vector-field
  1908. Xcells will be wrapped toriodally.
  1909. X.RE
  1910. X.TP 5
  1911. X\fB\-f\fP \fIfilter\fP (default \fBbox\fP)
  1912. XSpecifies the filter shape to use for the LIC.
  1913. XAvailable filters are:
  1914. X.PP
  1915. X.RS
  1916. X.TP 8
  1917. X.B box
  1918. XSpecifies a constant box shape filter: \fIk\fP(\fIs\fP) =  1.
  1919. XAll input image pixels along LIC paths will be given equal weight.
  1920. X.TP 8
  1921. X.B ripple
  1922. XSpecifies a phase shifted Hanning ripple function, windowed by a Hanning
  1923. Xfunction: \fIk\fP(\fIs\fP) = (cos(\fId\fP*\fIs\fP + \fIphase\fP) + 1)/2
  1924. X* (cos(\fIc\fP*\fIs\fP) + 1)/2.
  1925. XWhere
  1926. X.I d
  1927. Xand
  1928. X.I c
  1929. Xare the dilation constants for the ripple and window functions,
  1930. Xrespectively, and
  1931. X.I phase
  1932. Xis the phase shift of the ripple function.
  1933. X.I d
  1934. Xand
  1935. X.I c
  1936. Xcontrol the number of cycles of the Hanning functions over the filter kernel
  1937. Xfrom
  1938. X.RI - L
  1939. Xto
  1940. X.RI + L .
  1941. X.I d
  1942. Xis controlled by the
  1943. X.B \-d
  1944. Xoption and
  1945. X.I c
  1946. Xis always equal to
  1947. X.BR 1 .
  1948. X.I phase
  1949. Xis controlled by the
  1950. X.B \-p
  1951. Xoption.
  1952. X.TP 8
  1953. X.B ramp
  1954. XSpecifies a ramp shape filter whose value is
  1955. X.B 0
  1956. Xat
  1957. X.RI - L
  1958. Xand
  1959. X.B 1
  1960. Xat
  1961. X.RI + L :
  1962. X\fIk\fP(\fIs\fP) = (\fIs\fP + \fIL\fP) / 2\fIL\fP.
  1963. X.TP 8
  1964. X.B select
  1965. XSpecifies a filter which is used to select an approximately one pixel
  1966. Xwide window near the end of the advected streamline and place it at
  1967. Xthe advection starting pixel.  This is achieved using a narrow
  1968. XGaussian filter and placing this filter near the end of the advected
  1969. Xstreamline.  This can be used to produce a warp of the input image.
  1970. X.RE
  1971. X.TP 5
  1972. X\fB\-n\fP \fInormalization\fP (default \fBvariable\fP)
  1973. XSpecifies the type of normalization to be used:
  1974. X.B fixed
  1975. Xor
  1976. X.BR variable .
  1977. XWith
  1978. X.B fixed
  1979. Xnormalization, output image pixels will be attenuated near input vector
  1980. Xfield singularities and edges of the input vector field where vectors are not
  1981. Xparallel to the edges.
  1982. XWith
  1983. X.B variable
  1984. Xnormalization, output image pixels will maintain an even brightness level
  1985. X(relative to the input image pixels they are summed from).
  1986. X.TP 5
  1987. X\fB\-N\fP
  1988. XSpecifies that the input vector field is normalized: all vectors have
  1989. Xmagnitude 1 or 0.  If the vector field is not normalized, a separate
  1990. Xnormalized copy will be constructed for use in the convolution
  1991. Xmethods.  This may affect the ability to handle large problems because
  1992. Xof memory constraints.  If this becomes a problem, you may want to
  1993. Xconsider pre-normalizing the vector field.  However, this isn't an
  1994. Xoption if you want to do variable length or variable speed convolution
  1995. Xsince the vector magnitudes are used to control the length and speed
  1996. Xvariations (see variable length and variable speed documentation
  1997. Xbelow).
  1998. X.TP 5
  1999. X\fB\-l\fP \fIfilter-length\fP (default \fB10.0\fP)
  2000. XSpecifies the length,
  2001. X.IR L ,
  2002. Xof the filter kernel.  The length of the filter kernel will actually be
  2003. X.RI 2* L ,
  2004. Xextending from
  2005. X.RI - L
  2006. Xto
  2007. X.RI + L .
  2008. X.PP
  2009. X\fB\-d\fP \fIfilter-frequency\fP (default \fB3.0\fP)
  2010. X.br
  2011. X\fB\-p\fP \fIfilter-phase\fP (default \fB0.0\fP)
  2012. X.RS 5
  2013. XSpecifies the frequency and phase of the filter kernel.
  2014. X.I filter-frequency
  2015. Xis interpreted as the number of cycles of the filter kernel over the domain
  2016. X.RB - \*(pi
  2017. Xto
  2018. X.BR \*(pi .
  2019. X.I filter-phase
  2020. Xis interpreted as the phase offset of the filter kernel in the same domain.
  2021. XBoth
  2022. X.I filter-frequency
  2023. Xand
  2024. X.I filter-phase
  2025. Xare scaled to the length of the filter kernel.  Thus, a
  2026. X.I filter-frequency
  2027. Xof 2 will cause two repetitions of the filter kernel across the domain
  2028. X.RI - L
  2029. Xto
  2030. X.RI + L .
  2031. XCurrently, only the
  2032. X.B ripple
  2033. Xfilter uses these options.
  2034. X.RE
  2035. X.TP 5
  2036. X\fB\-L\fP
  2037. XSpecifies that variable length filtering should be performed.  The LIC
  2038. Xfilter length for each vector \fIv\fP will vary from 0 to
  2039. X.I L
  2040. Xbased on the vector's magnitude.  This magnitude scaling is performed
  2041. Xby finding the maximum magnitude vector in the input vector field,
  2042. X\fImax_v\fP, and then using a filter length equal to
  2043. X\fIL\fP  * ||\fIv\fP|| / ||\fImax_v\fP||.
  2044. XThe filter will be dilated to match the length of the convolution.
  2045. XThis prevents any visual artifacts which might occur because of abrupt
  2046. Xfilter truncation if the filter were not dilated.
  2047. X.TP 5
  2048. X\fB\-S\fP
  2049. XSpecifies that variable
  2050. X.I speed
  2051. Xfiltering should be performed.
  2052. XHigh magnitude regions of the vector field will use high
  2053. X.I speed
  2054. Xversions of the filter.  These higher speeds variations are typically
  2055. Xfrequency scaled versions of the base filter and are used in periodic
  2056. Xmotion animations to give the appearance of higher speed in higher magnitude
  2057. Xregions of the vector field.
  2058. XHowever, it is up to each filter to implement its own interpretation of
  2059. X.IR speed .
  2060. X.PP
  2061. XFor the
  2062. X.B ripple
  2063. Xfilter, the speed variations use a different frequency for each vector
  2064. X.I v
  2065. Xbased on its magnitude.  These frequency variations vary from 6 *
  2066. X.I filter-frequency
  2067. Xfor zero magnitude vectors to
  2068. X.I filter-frequency
  2069. Xfor maximum magnitude vectors.  Variable speed filtering is currently only
  2070. Ximplemented by the
  2071. X.B ripple
  2072. Xfilter (it doesn't have any effect on the
  2073. X.B box
  2074. Xfilter and is of dubious value for the
  2075. X.B ramp
  2076. Xfilter.)
  2077. X.PP
  2078. X\fB\-r\fP \fIdefault-red\fP (default \fB-1\fP)
  2079. X.br
  2080. X\fB\-g\fP \fIdefault-green\fP (default \fB-1\fP)
  2081. X.br
  2082. X\fB\-b\fP \fIdefault-blue\fP (default \fB-1\fP)
  2083. X.br
  2084. X\fB\-a\fP \fIdefault-alpha\fP (default \fB-1\fP)
  2085. X.RS 5
  2086. XDefine the default red, green, blue and alpha pixel values to use to represent
  2087. Xzero magnitude vectors.  A value of
  2088. X.B -1
  2089. Xspecifies that the underlaying input image pixel value should be used.
  2090. XFor
  2091. X.B MONOCHROME
  2092. Ximages,
  2093. X.I default-alpha
  2094. Xcontrols the default pixel value.
  2095. X.RE
  2096. X.TP 5
  2097. X\fB\-v\fP
  2098. XCauses verbose performance information to be output on standard output.
  2099. XDuring the execution of the convolution, a message will be printed
  2100. Xperiodically and after completion of the convolution, overall performance
  2101. Xstatistics figures will be printed.
  2102. X.TP 5
  2103. X\fB\-V\fP
  2104. XCauses configuration information about the LIC library version to be printed.
  2105. XCurrently the size of pixels and their types,
  2106. X.BR RGB ,
  2107. X.BR ABGR ,
  2108. X.BR MONOCHROME ,
  2109. Xetc. are controlled by library compile-time definitions.
  2110. X.SH ERRORS
  2111. XObjections to bad command line arguments, missing files, wrong size files,
  2112. Xoutput files already existing, etc.  Additionally, complaints about not
  2113. Xbeing able to map files into memory
  2114. X.RB ( mmap
  2115. Xversion) or inability to allocate memory
  2116. X.RB ( malloc
  2117. Xversion).
  2118. X.SH "SEE ALSO"
  2119. X.BR LIC (3),
  2120. X.BR LIC_Filters (3)
  2121. X.SH BUGS
  2122. XPixel types and sizes are configured into the LIC software at compile time.
  2123. XOnly single precision vector field ordinate values are supported.  These should
  2124. Xboth be handled dynamically at run time.
  2125. X.SH STANDARDS
  2126. XThis is unsupported, non-standard software.  It is not the subject of any
  2127. Xstandards effort.
  2128. END_OF_FILE
  2129.   if test 10950 -ne `wc -c <'lic.1.2/lic/lic.1'`; then
  2130.     echo shar: \"'lic.1.2/lic/lic.1'\" unpacked with wrong size!
  2131.   fi
  2132.   # end of 'lic.1.2/lic/lic.1'
  2133. fi
  2134. echo shar: End of archive 7 \(of 10\).
  2135. cp /dev/null ark7isdone
  2136. MISSING=""
  2137. for I in 1 2 3 4 5 6 7 8 9 10 ; do
  2138.     if test ! -f ark${I}isdone ; then
  2139.     MISSING="${MISSING} ${I}"
  2140.     fi
  2141. done
  2142. if test "${MISSING}" = "" ; then
  2143.     echo You have unpacked all 10 archives.
  2144.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2145. else
  2146.     echo You still must unpack the following archives:
  2147.     echo "        " ${MISSING}
  2148. fi
  2149. exit 0
  2150. exit 0 # Just in case...
  2151.