Learn ImageMagick - Batch Processing & Scripting

#Introduction

In episode 9 you processed many frames in a single image list. But imagine: 10,000 product photos that must be resized to three different sizes for a website, or 500 screenshots that must be reformatted on every build. Writing commands one by one is impossible; combining everything into one image list is also impractical for that many files.

The answer is batch processing: processing many files at once with a single command, or handing the work to a script that repeats it automatically. This episode equips you with mogrify, glob patterns, shell loops, and parallelism — four tools that turn ImageMagick from an image editor into a pipeline engine.

#Mogrify: Editing Many Files In-Place

magick mogrify is a sibling of magick designed specifically for editing many files: all matching files are processed one by one, and the results are written back to the same files:

magick mogrify -resize 50% *.jpg

Every .jpg file in the current directory is resized to half its size and saved under the same name. Because it modifies the original files, this command is extremely dangerous if run without preparation.

#Glob Patterns and Output Directories

The command above uses the glob pattern *.jpg. Shell globs can be extended further: *.{png,jpg} matches PNG and JPG at once, and with shopt -s globstar in bash, **/*.png matches PNGs across all subdirectories. Once the pattern is right, you can specify the output destination with -path:

magick mogrify -resize 50% -path thumbnails/ *.jpg

-path thumbnails/ writes the results to the thumbnails/ directory without touching the original files — the originals stay intact, and the resized results are collected in one place. Make sure the directory already exists; ImageMagick doesn't create it automatically. The mogrify + -path pattern is the safest combination for processing large collections.

#Writing Loops with for

Sometimes mogrify isn't enough — for example when the output name must be different or each file needs its own settings. That's where shell scripts come in. The most basic for loop:

for f in *.jpg; do
  magick "$f" -resize 800x -quality 85 "web/${f%.jpg}.jpg"
done

Notice two things. First, "$f" is always quoted — important because file names can contain spaces. Second, the expression f%.jpg strips the extension from the file name, so foto 1.jpg becomes web/foto 1.jpg. Writing loops gives you full control over naming and option order, and magick "$f" -resize 800x is the most flexible form of the per-file resize command.

#while Loops for Lists from Files

for loops work with lists already in memory. If the file list comes from a text file or search results, a while loop is more appropriate:

while IFS= read -r f; do
  magick "$f" -resize 800x "web/$(basename "$f")"
done < daftar-file.txt

read -r reads one full line without breaking on spaces, and $(basename "$f") extracts just the file name from the full path. This pattern is useful when you filter files by complex criteria — for example only files listed in a database, rather than all files in a directory.

#Parallelism with xargs -P

Processing 10,000 files sequentially takes a long time — even though your CPU may still have plenty of idle capacity. xargs with -P runs several processes at once:

find foto -name '*.jpg' -print0 | xargs -0 -P 4 -I {} \
  magick {} -resize 1200x "foto/web/{}"

A quick breakdown: find ... -print0 produces a file list with null separators to be safe against spaces; -0 tells xargs the format; -P 4 runs four ImageMagick processes in parallel; -I {} replaces {} with the file name in each command. The result: four files processed simultaneously, and the total time drops dramatically on multi-core machines.

#Idempotent Pipelines

A pipeline is said to be idempotent if running it repeatedly gives the same result, and running it again doesn't corrupt previous results. Without intending to, batch scripts often violate this principle — for example re-encoding JPEGs on every run, which accumulates compression artifacts.

The simplest way to make a pipeline idempotent: skip files whose results already exist:

for f in *.jpg; do
  out="web/${f%.jpg}.jpg"
  [ -f "$out" ] && continue
  magick "$f" -resize 800x "$out"
done

[ -f "$out" ] && continue means "if the output already exists, skip this file". Running the script twice doesn't double the work — finished files are skipped, and only files that don't exist yet are processed. Scripts like this can be stopped mid-run and re-run without fear of corrupting results. Idempotency also makes pipelines safe to schedule via cron or CI.

#Verifying Batch Results

A batch finishing doesn't mean the results are correct. Before the collection is used, verify a sample with magick identify:

magick identify web/foto-01.jpg web/foto-02.jpg

identify prints the format, dimensions, and file size for each listed image. From the output you can confirm the resize ran as expected — for example that all thumbnails really are 800 pixels. Checks like this should be chained into the same script so failures are detected early.

#Closing

In episode 10 you've processed many files at once with magick mogrify — complete with glob patterns, -path for output directories, and a stern warning about overwriting original files — written for and while loops in the shell, run parallel processes with xargs -P, and built idempotent pipelines that are safe to re-run.

The takeaway: batch processing turns working time from manual into automatic, and idempotency makes it safe. The cleaner the glob patterns and output naming, the fewer surprises when the script runs on a new collection.

In the next episode 11 we move into an often-underestimated aspect that determines the final quality: color management — ICC profiles, colorspace conversion, and HDRI for wide dynamic range. See you then!