A shell script around the ImageMagick "convert" command. Shrink jpegs in a source directory to 25% of the original width/height.

resize_photos.sh

#!/bin/bash
# This program passes shellcheck (www.shellcheck.net)
# Author: David Tonhofer
# Complexity: Low
# License: Public Domain / "The Unlicense" - https://unlicense.org/
# Also at https://gist.github.com/dtonhofer/6c44186d65d3b15784b64096e60195a0

# ===
#
# Synopsis:
#
#    Give help message:
#
#      ./resize_photos.sh --help
#
#    Dry-run, maybe creates $TARGET:
#
#      ./resize_photos.sh --srcdir $SOURCE --destdir $TARGET
#
#    Actual run, processes jpgs in $SOURCE and writes them to $DEST which
#    is deleted before it is recreated ("--cleanup")
#
#      ./resize_photos.sh --srcdir $SOURCE --destdir $DEST --cleanup --reallydo
#
#
# (you can also put '=' between option and argument)
#
# ===
#
# Description:
#
# Convert every (jpg) image found in a source directory given on the commandline
# by resizing it by 25% and putting the result into a destination directory, also
# given on the commandline.
#
# The 25% is currently hardcoded
#
# - If the destination directory does not exist, it is created.
#
# - If "--cleanup" is given on the commandline, and the destination directory exists,
#   it is removed before processing starts.
#
# - Nothing happens (except destination directory creation) unless "--reallydo" has
#   been given on the commandline (i.e. a "dryrun" is the default behaviour).
#
# - Destination file names are based on the original file names, with a ".small."
#   inserted before the ending, so one gets "foo.small.jpg" for example.
#
# - If "--nosuffix" is given, then the ".small." string is not inserted, the
#   destination filename is the same as the source filename.
#
# - The conversion will replace any target file in case of a name clash.
#
# - If the destination directory is the same as source directory the "small" files
#   will be created in the source directory.
#
# ===

set -o nounset

percentage=25

# ===
# Two functions below taken from
# http://blog.publicobject.com/2006/06/canonical-path-of-file-in-bash.html
# ===

# ---
# Get the canonical path of a file or directory.
# When the file or directory itself is a link then this is not resolved.
#
# Note: the '&> /dev/null' is needed because the 'cd' command will also
# print the directory into which it changes when the CDPATH environment
# variable is set.
#
# 1: the file or directory
# ---

function path-canonical-simple() {
   local dst="${1}"
   cd -P -- "$(dirname -- "${dst}")" &> /dev/null && echo "$(pwd -P)/$(basename -- "${dst}")"
}

# ---
# Get the canonical path of a file or directory.
# When the file or directory itself is a link then this is also resolved.
#
# 1: the file or directory
# ---

function path-canonical() {
   local dst="$(path-canonical-simple "${1}")"
   while [[ -h "${dst}" ]]; do
      local linkDst="$(ls -l "${dst}" | sed -r -e 's/^.*[[:space:]]*->[[:space:]]*(.*)[[:space:]]*$/\1/g')"
      if [[ -z "$(echo "${linkDst}" | grep -E '^/')" ]]; then
         # relative link destination
         linkDst="$(dirname "${dst}")/${linkDst}"
      fi
      dst="$(path-canonical-simple "${linkDst}")"
   done
   echo "${dst}"
}

# ===
# Check whether ImageMagick 'convert' is around, using the bash builtin "command" (replaces "which")
# ===

convertcommand=$(command -v convert) || {
   echo "The command 'convert' does not exist." >&2
   echo "You may have to install package 'ImageMagick' first!" >&2
   exit 1
}

# ===
# Stuff set from the command line
# ===

reallydo=  # set if this is not a "dryrun"
cleanup=   # will remove targetdir if it exist before starting conversion
srcdir=    # source directory with files to resize
destdir=   # target directory in which smaller files will be created
nosuffix=  # do not insert the "small" suffix

processOptions() {

   local print_help=
   local use_srcdir=
   local use_destdir=
   local unknown=

   for param in "$@"; do

      #
      # get value or previously given option
      #

      if [[ -n $use_srcdir ]]; then
         srcdir=$param
         use_srcdir=""
         continue
      fi

      if [[ -n $use_destdir ]]; then
         destdir=$param
         use_destdir=""
         continue
      fi

      #
      # Process "--option=arg" elements, but also cater for "--option arg" style
      #

      if [[ $param =~ ^--srcdir(=.+)? ]]; then
         if [[ $param =~ ^--srcdir=(.+)? ]]; then
            srcdir=$(echo "$param" | cut --delimiter="=" --fields=2)
         else
            use_srcdir=1
         fi
         continue
      fi

      if [[ $param =~ ^--destdir(=.+)? ]]; then
         if [[ $param =~ ^--destdir=(.+)? ]]; then
            destdir=$(echo "$param" | cut --delimiter="=" --fields=2)
         else
            use_destdir=1
         fi
         continue
      fi

      #
      # get flag
      #

      if [[ $param == '--cleanup' ]]; then
         cleanup=1
         continue
      fi

      if [[ $param == '--reallydo' ]]; then
         reallydo=1
         continue
      fi

      if [[ $param == '--nosuffix' ]]; then
         nosuffix=1
         continue
      fi


      # Special case: "--help" or "-h"

      if [[ $param == '--help' || $param == '-h' ]]; then
         print_help=1
         break
      fi

      # if we are here, we encountered something unknown in "param";
      # if "unknown" is already set, add a comma for separation

      if [[ -n $unknown ]]; then
         unknown="$unknown,"
      fi

      unknown="${unknown}${param}"

   done

   if [[ -n $unknown ]]; then
      echo "Unknown parameters: '$unknown' -- exiting" >&2
      print_help=1
   fi

   if [[ -n $print_help ]]; then
cat >&2 <<HERE
Resize photos!

--reallydo      Really perform changes. Otherwise this is just a dryrun.
--cleanup       Will remove "trgdir" and its contents if it exists, then re-create it.
--nosuffix      Do not insert the string ".small." into destination filenames.
--srcdir=DIR    Directory containing files to process.
--destdir=DIR   Directory in which resized files are created. Created if it does not exist.
HERE
      exit 1
   fi
}

processOptions "$@"

# echo "Reallydo  = $reallydo"
# echo "Cleanup   = $cleanup"
# echo "Srcdir    = $srcdir"
# echo "Destdir   = $destdir"

# ---
# Check what has been passed
# ---

if [[ -z "$srcdir" ]]; then
   echo "Source directory not given -- exiting!" >&2
   exit 1
fi

if [[ -z "$destdir" ]]; then
   echo "Destination directory not given -- exiting!" >&2
   exit 1
fi

if [[ ! -d "$srcdir" ]]; then
   echo "Passed source directory '$srcdir' does not exist -- exiting!" >&2
   exit 1
fi

# This even handles '~'

srcdir=$(path-canonical "$srcdir")
destdir=$(path-canonical "$destdir")

echo "Passed source directory made canonical: $srcdir" >&2
echo "Passed destination directory made canonical: $destdir" >&2

if [[ "$srcdir" == "$destdir" ]]; then
   # This just checks name equality.
   # This is weak as the directory names could be aliases of the same directory.
   echo "Source directory and destination directory are the same." >&2
   if [[ -n $nosuffix ]]; then
      echo "Source directory and destination directory must differ in case of '--nosuffix'." >&2
      exit 1
   fi
else
   if [[ -e "$destdir" && ! -d "$destdir" ]]; then
      echo "Destination directory exists but is not actually a directory -- exiting" >&2
      exit 1
   fi
   if [[ -n $cleanup ]]; then
      if [[ -z $reallydo ]]; then
         echo "Skipping check about whether destination directory should be deleted because this is a dryrun." >&2
      else
         if [[ -d "$destdir" ]]; then
            echo "Destination directory '$destdir' already exists ... removing it!" >&2
            # do not wildly delete recursively, but be somewhat cautious
            countfiles=$(find "$destdir" -maxdepth 1 -mindepth 1 -type f | wc -l)
            countany=$(find "$destdir" -mindepth 1  | wc -l)
            if [[ $countfiles -eq $countany ]] ; then
               find "$destdir" -maxdepth 1 -type f -delete
               rmdir "$destdir" || {
                  echo "Could not remove existing destination directory '$destdir' -- exiting" >&2
                  exit 1
               }
            else
               echo "Destination directory '$destdir' is not a single directory with files inside ... NOT removing this!" >&2
            fi
         fi
      fi
   fi
fi

# ---
# Create the destination directory if it is missing.
# This is done even in the case of a "dryrun"
# ---

if [[ ! -d "$destdir" ]]; then
   mkdir "$destdir" || {
      echo "'$destdir' does not exist but could not create it -- exiting" >&2
      exit 1
   }
fi

# ---
# cd to the srcdir and destdir to make doubly sure they exist and can be accessed
# ---

cd "$srcdir" || {
   echo "Could not cd to '$srcdir' -- exiting" >&2
   exit 1
}

cd "$destdir" || {
   echo "Could not cd to '$destdir' -- exiting" >&2
   exit 1
}

# ---
# Collect files before processing starts, and not using "ls"!
# Actually one could use "readarray" here
# ---

unset thefiles
declare -a thefiles

while IFS= read -r -u3 -d $'\0' somefile; do
    thefiles+=( "$somefile" )
done 3< <(find "$srcdir" -maxdepth 1 -type f -print0)

# ---
# Process files!
# ---

for somefile in "${thefiles[@]}"; do

   # echo "Processing $somefile" >&2

   mimetype=$(file --brief --mime-type "$somefile")
   if [[ $mimetype != "image/jpeg" ]]; then
      echo "Skipping file '$somefile' with mime type '$mimetype'" >&2
      continue
   fi

   base=$(basename "$somefile")
   if [[ -n $nosuffix ]]; then
      newbase=$base
   else
      newbase=$(echo "$base" | perl -n -e 'if ( ~/^(.+)\.(\w+)$/ ) { print "$1.small.$2" } else { print "$_.small" }')
   fi

   # echo "$base --> $newbase" >&2
   # echo "$srcdir/$base --> $destdir/$newbase" >&2

   if [[ -n $reallydo ]]; then

      # Here it is! Putting the job into the background and waiting for it allows CTRL-C
      # to kill the script, not just the command

      "$convertcommand" "$srcdir/$base" -verbose -resize "${percentage}%" "$destdir/$newbase" &
      wait

   else
      echo "Dryun: $convertcommand '$srcdir/$base' -resize ${percentage}% '$destdir/$newbase'" >&2
   fi

done