Work the Shell - Displaying Image Directories in Apache, Part IV

 in
The final steps in our thumbnail script scale and align the images within a pretty table.

This is the fourth of four columns on how to write a shell script to make the display of directories full of images more useful than the default Apache ls -l style output.

In the first column, I explained how to drop a script in place to improve the Apache directory listing capability, and in the latter two columns, I showed how to work with images within a shell script, including a shell function that extracted height and width from most image file types.

I ended that column with a teaser, highlighting that if you really want to work with images on the command line, there's no better package than ImageMagick. You'll want it for this month's installment (www.imagemagick.org), if it's not already installed on your server.

Rewriting the Image Size Function

The first stab at the image size function figuresize() leaned on the file command to figure out image size. This works for GIF and PNG images, but it turns out that the file command can't figure out the image size for JPEG images, alas. So, we need to rewrite it using the ImageMagick identify script instead. Here's a sample (pruned) output:

$ identify teamgeist.jpg hentai-manga-example.gif archos-av700.png 
teamgeist.jpg JPEG 350x350 350x350+0+0 DirectClass 8-bit 62.7734kb 
hentai-manga-example.gif GIF 358x313 358x313+0+0 PseudoClass 256c 
 ↪8-bit 86.4551kb 
archos-av700.png PNG 567x294 567x294+0+0 DirectClass 
 ↪8-bit 341.498kb

Notice that in all three cases, the image dimensions are shown as field three, in width x height format (for example, archos-av700.png is 567 pixels wide and 294 pixels high).

This means we can use cut to grab only those values and cut again to strip out field one and field two, like this:

width="$(identify $1|cut -d\  -f3|cut -dx -f1)"
height="$(identify $1|cut -d\  -f3|cut -dx -f2)"

If we add an echo, we have a rudimentary image size shell script. With that done, let's test it out with the Archos PNG file and the Teamgeist image that the file command couldn't handle:

$ sh myidentify.sh archos-av700.png 
archos-av700.png: height=294 and width=567
$ sh myidentify.sh teamgeist.jpg 
teamgeist.jpg: height=350 and width=350

Perfect. The figuresize() shell function is given an image filename and sets the global variables height and width, so it's easy to rewrite it to work with identify:

figuresize()
{
    width="$(identify $1|cut -d\  -f3|cut -dx -f1)"
   height="$(identify $1|cut -d\  -f3|cut -dx -f2)"
}

This is much smaller, much more efficient, and it works with JPEG images too—an all-around win!

Scaling Images Proportionally

The last step in our script development is to let more than one image be displayed on a line, because we now can reduce thumbnails as needed, whether they're wide or tall. Here, I write this to have three images abreast, but you can tweak it if you have a bigger screen, of course.

To have three images across in a window that'll be no wider than 700 pixels (to fit easily on an 800x600 screen), we want the thumbnail images to be no wider than 200 pixels. This means we want to call figuresize(), and then do some math to figure out the best reduced dimensions to get to that max.

The challenge is that the shell doesn't really let you work with floating-point (non-integer) numbers, so we need to trick bc into doing the work for us. Here's how that looks if height is the larger dimension:

factor="$(echo "scale=4;$maxsize/$height"|bc)"
newwidth="$(echo "$factor*$width"|bc|cut -d. -f1)"

To figure out how to scale the smaller dimension proportionally, we divide MAXSIZE/actual height, which will be a value less than 1.0, and then use that as the multiplier for the other dimension.

For example, let's say I have an image that's 313x358 but want to reduce it to no bigger than 200x200, proportionally; factor can be calculated as 200/358 (or .558), and then the smaller dimension is multiplied by .558 (that is, 313*0.558) to produce 174. The proportionally scaled image, then, is 174x200.

In script form, here's what I wrote:

if [ $height -gt $maxsize -o $width -gt $maxsize ] ; then
  if [ $height -gt $width ] ; then
    # we'll want to constrain height
    factor="$(echo "scale=4;$maxsize/$height"|bc)"
    nh=$maxsize
    nw="$(echo "$factor*$width"|bc|cut -d. -f1)"
  else
    factor="$(echo "scale=4;$maxsize/$width"|bc)"
    nw=$maxsize
    nh="$(echo "$factor*$height"|bc|cut -d. -f1)"
  fi

  echo "Given $width x $height, scaled to "
  echo "$nw x $nh"  
      
  width=$nw  
  height=$nh
fi

Cool. Now if the image is too big, we can scale it automatically and adjust the height and width parameters as needed. If it's sufficiently small, nothing changes. A test run:

  • Given 161x230, scaled to 139x200.

  • Given 268x202, scaled to 200x150.

  • Given 567x294, scaled to 200x103.

  • Given 358x313, scaled to 200x174.

  • Given 350x350, scaled to 200x199.

______________________

Dave Taylor has been hacking shell scripts for over thirty years. Really. He's the author of the popular "Wicked Cool Shell Scripts" and can be found on Twitter as @DaveTaylor and more generally at www.DaveTaylorOnline.com.

Comments

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

finally

ultramookie's picture

i agree, finally this series is over.

hey dave, on a different note, your example picture kind of shows what kind of stuff you're into, huh?

"hentai-manga-example.gif"?

http://en.wikipedia.org/wiki/Hentai

"[I]n slang situations it often means 'perverted' and is subsequently used in many other countries to refer to anime, manga and computer games with explicit sexual or pornographic content.

"The term "hentai" is also commonly used (outside of Japan) to refer to pornographic animation in general that is not necessarily anime or manga. This is most often the case if the said animation is an imitation of a pre-existing cartoon or character."

finally

etamme's picture

finally this series is over...

White Paper
Linux Management with Red Hat Satellite: Measuring Business Impact and ROI

Linux has become a key foundation for supporting today's rapidly growing IT environments. Linux is being used to deploy business applications and databases, trading on its reputation as a low-cost operating environment. For many IT organizations, Linux is a mainstay for deploying Web servers and has evolved from handling basic file, print, and utility workloads to running mission-critical applications and databases, physically, virtually, and in the cloud. As Linux grows in importance in terms of value to the business, managing Linux environments to high standards of service quality — availability, security, and performance — becomes an essential requirement for business success.

Learn More

Sponsored by Red Hat

White Paper
Private PaaS for the Agile Enterprise

If you already use virtualized infrastructure, you are well on your way to leveraging the power of the cloud. Virtualization offers the promise of limitless resources, but how do you manage that scalability when your DevOps team doesn’t scale? In today’s hypercompetitive markets, fast results can make a difference between leading the pack vs. obsolescence. Organizations need more benefits from cloud computing than just raw resources. They need agility, flexibility, convenience, ROI, and control.

Stackato private Platform-as-a-Service technology from ActiveState extends your private cloud infrastructure by creating a private PaaS to provide on-demand availability, flexibility, control, and ultimately, faster time-to-market for your enterprise.

Learn More

Sponsored by ActiveState