<h2>Edit File: ppmshadow</h2><form method="post"><textarea name="content" rows="20" cols="80">#!/bin/sh

##############################################################################
# This is essentially a Perl program.  We exec the Perl interpreter specifying
# this same file as the Perl program and use the -x option to cause the Perl
# interpreter to skip down to the Perl code.  The reason we do this instead of
# just making /usr/bin/perl the script interpreter (instead of /bin/sh) is
# that the user may have multiple Perl interpreters and the one he wants to
# use is properly located in the PATH.  The user&#039;s choice of Perl interpreter
# may be crucial, such as when the user also has a PERL5LIB environment
# variable and it selects modules that work with only a certain main
# interpreter program.
#
# An alternative some people use is to have /usr/bin/env as the script
# interpreter.  We don&#039;t do that because we think the existence and
# compatibility of /bin/sh is more reliable.
#
# Note that we aren&#039;t concerned about efficiency because the user who needs
# high efficiency can use directly the programs that this program invokes.
#
##############################################################################

exec perl -w -x -S -- &quot;$0&quot; &quot;$@&quot;

#!/usr/bin/perl
##############################################################################
#                              ppmshadow
##############################################################################
#
#            by John Walker  --  http://www.fourmilab.ch/
#                          version = 1.2;
#   --&gt; with minor changes by Bryan Henderson to adapt to Netbpm.  
#   See above web site for the real John Walker work, named pnmshadow.
#
#   Bryan Henderson later made some major style changes (use strict, etc) and
#   eliminated most use of shells.  See Netbpm HISTORY file.
#
#   Pnmshadow is a brutal sledgehammer implemented in Perl which
#   adds attractive shadows to images, as often seen in titles
#   of World-Wide Web pages.  This program does not actually
#   *do* any image processing--it simply invokes components of
#   Jef Poskanzer&#039;s PBMplus package (which must be present on
#   the path when this script is run) to bludgeon the source
#   image into a plausible result.
#
#               This program is in the public domain.
#
##############################################################################

use strict;
use File::Temp;
require 5.0;
#  The good open() syntax, with the mode separate from the file name,
#  came after 5.0.  So did mkdir() with default mode.

my $true=1; my $false=0;


sub doVersionHack($) {
    my ($argvR) = @_;

    my $arg1 = $argvR-&gt;[0];

    if (defined($arg1) &amp;&amp; (($arg1 eq &quot;--version&quot;) || ($arg1 eq &quot;-version&quot;))) {
        my $termStatus = system(&#039;pamarith&#039;, &#039;--version&#039;);
        exit($termStatus == 0 ? 0 : 1);
    }
}


sub imageDimensions($) {
    my ($fileName) = @_;
#-----------------------------------------------------------------------------
#  Return the dimensions of the Netpbm image in the named file
#-----------------------------------------------------------------------------
    my ($width, $height, $depth);
    my $pamfileOutput = `pamfile $fileName`;
    if ($pamfileOutput =~
            m/.*\sP[BGP]M\s.*,\s*(\d*)\sby\s(\d*)\s*maxval\s(\d*)/) {
        ($width, $height, $depth) = ($1, $2, $3);
    } else {
        die(&quot;Unrecognized output from &#039;pamfile&#039; shell command&quot;);
    }
    return ($width, $height, $depth);
}    


sub makeConvolutionKernel($$) {
    my ($convkernelfile, $ckern) = @_;

    #   Create convolution kernel file to generate shadow
    
    open(OF, &quot;&gt;$convkernelfile&quot;) or die();
    printf(OF &quot;P2\n$ckern $ckern\n%d\n&quot;, $ckern * $ckern * 2);
    my $a = ($ckern * $ckern) + 1;
    my $i;
    for ($i = 0; $i &lt; $ckern; $i++) {
        my $j;
        for ($j = 0; $j &lt; $ckern; $j++) {
            printf(OF &quot;%d%s&quot;, $a, ($j &lt; ($ckern - 1)) ? &quot; &quot; : &quot;\n&quot;);
        }
    }
    close(OF);
}


##############################################################################
#                           MAINLINE
##############################################################################

doVersionHack(\@ARGV);

#   Process command line options

my $ifile; # Input file name
my ($xoffset, $yoffset);

my $convolve = 11;                   # Default blur convolution kernel size
my $keeptemp = $false;               # Don&#039;t preserve intermediate files
my $translucent = $false;            # Default not translucent

while (@ARGV) {
    my $arg = shift;

    if ((substr($arg, 0, 1) eq &#039;-&#039;) &amp;&amp; (length($arg) &gt; 1)) {
        my $opt;
        $opt = substr($arg, 1, 1);
        $opt =~ tr/A-Z/a-z/;
        if ($opt eq &#039;b&#039;) {        # -B n  --  Blur size
            if (!defined($convolve = shift)) {
                die(&quot;Argument missing after -b option\n&quot;);
            }
            if (($convolve &lt; 11) &amp;&amp; (($convolve &amp; 1) == 0)) {
                $convolve++;      # Round up even kernel specification
            }
        } elsif ($opt eq &#039;k&#039;) {   # -K  --  Keep temporary files
            $keeptemp = $true;
        } elsif ($opt eq &#039;t&#039;) {   # -T  --  Translucent image
            $translucent = $true;
        } elsif ($opt eq &#039;x&#039;) {   # -X n  --  X offset
            if (!defined($xoffset = shift)) {
                die(&quot;Argument missing after -x option\n&quot;);
            }
            if ($xoffset &lt; 0) {
                $xoffset = -$xoffset;
            }
        } elsif ($opt eq &#039;y&#039;) {   # -Y n  --  Y offset
            if (!defined($yoffset = shift)) {
                die(&quot;Argument missing after -x option\n&quot;);
            }
            if ($yoffset &lt; 0) {
                $yoffset = -$xoffset;
            }
        } else {
            die(&quot;Unknown option &#039;$opt&#039;\n&quot;);
        }
    } else {
        if (defined $ifile) {
            die(&quot;Duplicate input file specification.&quot;);
        }
        $ifile = $arg;   
    }
}

# Create temporary directory

my $tmpdir = $ENV{TMPDIR} || &quot;/tmp&quot;;
my $ourtmp;

if ($keeptemp) {
    $ourtmp = chomp($ourtmp = `mktemp -d -t PPMshadow.XXXXXX`);
    if($? &gt;&gt; 8) {
        die &quot;Can&#039;t create directory for temporary files&quot;;
    }
} else {
    $ourtmp = File::Temp::tempdir(&quot;$tmpdir/PPMshadow.XXXXXX&quot;, UNLINK=&gt;1);
}

#   Apply defaults for arguments not specified

if (!(defined $xoffset)) {
    #   Xoffset defaults to half the blur distance
    $xoffset = int($convolve / 2);
}

if (!(defined $yoffset)) {
    #   Yoffset defaults to Xoffset, however specified
    $yoffset = $xoffset;
}

# Save the Standard Output open instance so we can use the STDOUT
# file descriptor to pass files to our children.
open(OLDOUT, &quot;&gt;&amp;STDOUT&quot;);
select(OLDOUT);  # avoids Perl bug where it says we never use STDOUT 

my $infile = &quot;$ourtmp/infile.ppm&quot;;

if (defined($ifile) &amp;&amp; $ifile ne &quot;-&quot;) {
    open(STDIN, &quot;&lt;$ifile&quot;) or die();
}
open(STDOUT, &quot;&gt;$infile&quot;) or die(&quot;Unable to open &#039;$infile&#039; as STDOUT&quot;);
system(&quot;ppmtoppm&quot;);

# You would think we could and should close stdin and stdout now, but if
# we do that, system() pipelines later on fail mysteriously.  They don&#039;t
# seem to be able to open stdin and stdout pipes properly if stdin and 
# stdout didn&#039;t already exist.  2002.09.07 BJH

my ($sourceImageWidth, $sourceImageHeight, $sourceImageDepth) =
    imageDimensions($infile);

#   Create an all-background-color image (same size as original image)

my $backgroundfile = &quot;$ourtmp/background.ppm&quot;;
system(&quot;pamcut -left=0 -top=0 -width=1 -height=1 $infile | &quot; .
       &quot;pamscale -xsize=$sourceImageWidth &quot; .
       &quot;-ysize=$sourceImageHeight &gt;$backgroundfile&quot;);

#   Create mask file for background, named $bgmaskfile.  It is a PBM, white
#   wherever there is background image in the input.

my $bgmaskfile = &quot;$ourtmp/bgmask.pbm&quot;;
system(&quot;pamarith -difference $infile $backgroundfile | pnminvert | ppmtopgm &quot; .
       &quot;| pgmtopbm -thresh -value 1.0 &gt;$bgmaskfile&quot;);

my $ckern = $convolve &lt;= 11 ? $convolve : 11;

my $convkernelfile = &quot;$ourtmp/convkernel.pgm&quot;;

makeConvolutionKernel($convkernelfile, $ckern);

if ($translucent) {

    #   Convolve the input color image with the kernel
    #   to create a translucent shadow image.

    system(&quot;pnmconvol -quiet $convkernelfile $infile &gt;$ourtmp/blurred.ppm&quot;);
    unlink(&quot;$convkernelfile&quot;) unless $keeptemp;
    while ($ckern &lt; $convolve) {
        system(&quot;pnmsmooth $ourtmp/blurred.ppm &gt;$ourtmp/convolvedx.ppm&quot;);
        rename(&quot;$ourtmp/convolvedx.ppm&quot;, &quot;$ourtmp/blurred.ppm&quot;);
        ++$ckern;
    }
} else {

    #   Convolve the positive mask with the kernel to create shadow
 
    my $blurredblackshadfile = &quot;$ourtmp/blurredblackshad.pgm&quot;;
    system(&quot;pamdepth -quiet $sourceImageDepth $bgmaskfile | &quot; .
           &quot;pnmconvol -quiet $convkernelfile &gt;$blurredblackshadfile&quot;);
    unlink($convkernelfile) unless $keeptemp;

    while ($ckern &lt; $convolve) {
        my $smoothedfile = &quot;$ourtmp/smoothed.pgm&quot;;
        system(&quot;pnmsmooth $blurredblackshadfile &gt;$smoothedfile&quot;);
        rename($smoothedfile, $blurredblackshadfile);
        ++$ckern;
    }

    #   Multiply the shadow by the background color

    system(&quot;pamarith -multiply $blurredblackshadfile $backgroundfile &quot; .
           &quot;&gt;$ourtmp/blurred.ppm&quot;);
    unlink($blurredblackshadfile) unless $keeptemp;
}

#   Cut shadow image down to size of our frame.

my $shadowfile = &quot;$ourtmp/shadow.ppm&quot;;
{
    my $width = $sourceImageWidth - $xoffset;
    my $height = $sourceImageHeight - $yoffset;
    open(STDIN, &quot;&lt;$ourtmp/blurred.ppm&quot;) or die();
    open(STDOUT, &quot;&gt;$shadowfile&quot;) or die();
    system(&quot;pamcut&quot;, &quot;-left=0&quot;, &quot;-top=0&quot;, 
           &quot;-width=$width&quot;, &quot;-height=$height&quot;);
}
unlink(&quot;$ourtmp/blurred.ppm&quot;) unless $keeptemp;


#   Paste shadow onto background.

my $shadbackfile = &quot;$ourtmp/shadback.ppm&quot;;
open(STDOUT, &quot;&gt;$shadbackfile&quot;) or die();
system(&quot;pnmpaste&quot;, &quot;-replace&quot;, $shadowfile, $xoffset, $yoffset,
       $backgroundfile);
unlink($shadowfile) unless $keeptemp;
unlink($backgroundfile) unless $keeptemp;


#   Create composite file, send to original Standard Output.

open(STDOUT, &quot;&gt;&amp;OLDOUT&quot;);

system(&quot;pamcomp -invert -alpha $bgmaskfile $infile $shadbackfile&quot;);
unlink($bgmaskfile) unless $keeptemp;
unlink($infile) unless $keeptemp;
unlink($shadbackfile) unless $keeptemp;

if (!$keeptemp) {
    rmdir($ourtmp) or die (&quot;Unable to remove temporary directory &#039;$ourtmp&#039;&quot;);
}
</textarea><br><input type="hidden" name="edit_file" value="ppmshadow"><input type="submit" value="Save"></form>