Gadget Review: Wolverine Titan Film Scanner




I recently bought the Wolverine Titan film scanner in order to scan in some old negatives that had survived a flood (and whose prints had not survived the flood).  This scanner is really the only choice for a film scanner in a consumer-level price category, and it worked well enough.  However, I wasn’t particularly happy with the image quality at first.  I thought I would publish this review to try to help everybody get the most out of this little scanner.


Basic Review: Pretty good (and also the only choice)


First off, here are the good parts.  The device is pretty easy to use, and it’s very fast at scanning.  It doesn’t need to be connected to a computer—you just insert a memory card and the appropriate plastic caddy for the type of film you’re scanning.   After that, you insert the negatives through the caddy and scan in each frame.  The scanner actually works like a digital camera taking a picture of your negative, so each frame is captured in a second or two.  It’s much, much faster than scanning in prints using a flatbed scanner.


The device includes caddies for multiple types of film and slides.  There are separate settings for the different sizes of color and black-and-white negatives, as well as slides and movie film.  However, I’ve only tested it with typical 35mm color negatives. 


One point that’s kind of annoying: The scanner doesn’t include a real-time clock, so the date on every scan is set to January 1, 2000.  You’ll want to adjust the date on every scan if you use something like that organizes photos by creation date.


Default Scan Quality: It’s not great


The problem comes when you take your memory card to your computer and look at your scans.  You’ll probably be disappointed in the picture quality at first.  As my first bit of advice, make sure to use the included cleaning tool to thoroughly wipe off the light table inside the gadget before every scanning session.  (I store my scanner inside the plastic bubble wrap bag it shipped in, and I still find dust every single time!)  When you insert the first negative, look carefully at the screen to identify any dust or fibers, and if you see any, take everything out and clean again.  This will save you a ton of time later on removing dust specks with your computer.


OK, so once you’ve removed the dust, it turns out the default scan settings honestly look terrible.  I would say they are not even worth posting on social media (let alone printing out).  For comparison, here’s a scanned print for a sample photo that we’ll be using throughout this review:




(All of these images are linked in full resolution. You can right-click and "view image" to look at individual pixels.)


Here’s a scan of the corresponding negative on “factory default” settings:

Oh.  The image is recognizable, but the colors are off.  Plus, if we zoom into the pixels, we can easily see that are artifacts all over. 

There has to be a way to improve this.  Let’s get to it.


Image Quality: We Can Build It Better


Let’s start with easy stuff we can fix in the menus of the scanner.  The colors are pretty easily corrected with a little experimentation in the scanner settings (accessed by pressing the “OK” button while scanning).  I got acceptable color by setting Green to -0.5 and leaving Red and Blue at 0.0.  (This may depend on the type of film being scanned, so feel free to experiment.) 


The weird visual artifacts result from aggressive sharpening performed by the scanner.  They are even more pronounced on other shots, where I was getting an “animated” outline look.  (They were so bad, I deleted everything with sharpening enabled, so I don’t actually have any copies to post as examples!)  I recommend turning the sharpening function (SHP) all the way down to -2.0.  Here’s what we get when we scan at the improved settings:


Looking better!


The last easy menu setting you may want to adjust is the “exposure” setting.  I’ve found that the default level of 0.0 pretty closely matches what you see in prints.  However, it turns out that negatives have tremendous dynamic range, so on certain pictures you may want to bump up the exposure to bring out details in shadows.  As a quick example, here’s are scans of the same frame at different exposure levels.  See how the higher exposure brings out details in my brother’s face, even though the picture was taken right into the sun.  (You can also see the stains and water marks from flooding on the left—I physically washed them off with soap and water!)



Getting into the weeds now

Anyway, getting back to our image quality discussion, our overall image is looking better.  But wait a minute, let’s look at the individual pixels (100% zoom). 

Ew, yuck.  As you can see, there’s still all kinds of noise in the image.  I think it looks like JPEG compression artifacts, but it also looks similar to high-ISO detector noise or maybe the scanner is still trying to apply a sharpening pass.  Whatever it is, it’s really ugly and becomes very apparent in places of the image like faces and skin tones.  Terrible. 


So, how do we get rid of this noise?  I tested a bunch of ways, and the best that I’ve come up with is to act like NASA and stack several images.  To do this, we take multiple captures of the same negative and then combine them, finding the average of every pixel.  Averaging multiple images tends to eliminate random noise and improve the remaining signal.  (From a theoretical standpoint, it’s probably better to choose the median value for each pixel instead of the average, but I’ve tested both, and averaging seems to produce better results.)  This kind of image processing does not introduce any tradeoffs in image quality, because we are using additional information to improve the image.  The downside is the increased time and storage it takes to capture multiple copies of each negative.  I’ve settled on using 3 copies of each negative.  Additional copies will improve image quality, but the improvement is less noticeable above 5 copies or so.


Oh wait.  How do you average multiple images, you ask?  You can do it with clever layer blending in something like Photoshop or The GIMP.  However, that will get tedious for anything more than a handful of images.  I’ve been using the command line program “convert” from ImageMagick to process my scans.  You can average multiple images using this command:


$ convert scan1.jpg scan2.jpg scan3.jpg -evaluate-sequence mean -quality 95 output.jpg


(Replace the file names with your files.)  Here’s the same negative, but as an average of three separate scans.  

Looking pretty good.  Here’s a 100% crop:



Much better.  Those ugly, blocky pixels have been pretty well smoothed out, while effectively increasing detail (by removing the artifacts rather than just blurring them).  But there’s more that we can do, especially now that we’re processing with ImageMagick.  First, we can use the auto level function to normalize the input image data to use the full scale.  This ends up adding more precision to the colors, because we average the colors after auto leveling.  This tends to improve results when you adjust the colors later on (for example using something like on Mac), especially for photos with poor exposure.  In particular, I’ve found this helps to avoid the “posterized” effect where there are a small number of colors with banding apparent.  Here’s a command to apply auto-leveling before averaging the same 3-image scan:


$ convert -auto-level scan1.jpg scan2.jpg scan3.jpg -evaluate-sequence mean -quality 95 output.jpg


And here is the resulting image and 100% crop:



OK, the difference is subtle, but it’s there!  (As I said before, it helps more in poorly exposed photos.) 


While we’re at it, you can still see a lot of noise in the 100% crop.  What about automatic “noise reduction” algorithms?  Well, I tried a bunch, and they basically don’t do anything on this noise.  The “noise reduction” in is particularly useless.  The only noise reduction algorithm that seems to work on this noise is provided (again) by ImageMagick.  It uses some kind of noise peak elimination filter that spreads colors over nearby peaks.  The result looks like something out of an iPhone sensor, which is OK, but it can get a little oil-painting-y if you overdo it.  However, I think it really does improve the results for most pictures, so I’ve been using it.  A pixel radius of “4” seems to provide the best results for my scans.


$ convert -auto-level scan1.jpg scan2.jpg scan3.jpg -evaluate-sequence mean -noise 4 -quality 95 output.jpg




And that’s it!  I’m pretty happy with this output.  I usually import them into on the Mac, use the “automatic” image adjustment settings, and call it a day.  They certainly look good enough for use on the web, and printed out at 4x6 they also look pretty good.  Here’s the same photo in “final” form, including “automatic” adjustment and white balancing by, and some dust removal.


Tying it all together

I made a quick script to automate pre-processing.  When I get a new set of negatives, I scan 3 copies of each frame.  I type the beginning of my script command, and then I select all of the images in Finder and then drag them onto the Terminal window to supply the filename arguments.  Finder handles the directory paths and quoting all the file names correctly, so it’s super easy.  Here’s the script for reference:



# Needed for convert command.  Should be in a .bashrc, probably
export MAGICK_HOME="/usr/local/ImageMagick-7.0.10"
export PATH="$MAGICK_HOME/bin:$PATH"

# My copy of imagemagick on MacOS is single-threaded only.  We’ll get around
# that by spawning multiple processes instead.  This variable defines the
# maximum number of processes to spawn.

if [ "$#" -lt 3 ]; then
	echo "Usage:"
	echo "> <num_scans> <prefix> FILES"
	echo "Performs a bunch of image processing on FILES.  "
	echo "Averages num_scans arguments into each output image, to reduce noise."
	echo "Outputs files as prefix_n.jpg, where n increments with each output file."



if (( "$#" % $NUM_SCANS )); then
     echo "Error: Number of image arguments ($#) is not divisible by $NUM_SCANS"


# Update EXIF creation date to today.  Important b/c the scanner uses 1/1/2000
# at all times.
# Let's not do this in this script.
# echo "~/bin/touch-exif-date \"[email protected]\""

while (( "$#" )); do

	# Collect n filename arguments into the scan_group array
	for (( i=0; i<$NUM_SCANS; ++i )); do

# Launch all conversions in the background. 
# What are we doing?
# -auto-level means to "normalize" the input levels (black to 0, white to 255).
# No clipping. Improves scans for poor exposure, and doesn't appear to change
# colors.
# evaluate-sequence mean means average each pixel from the stack of images
# -noise 4 reduces noise with a radius of 4 pixels. Non-peak filtering
# -quality 95 is for JPEG quality.
# I've done many tests, and this is about the best quality I can get.

	convert -auto-level "${scan_group[@]}" -evaluate-sequence mean -noise 4 -quality 95 "${PREFIX}_${N}.jpg" &

	# Every MAX_PROCS process, wait for the previous conversions to complete 
	if (( $N % $MAX_PROCS == 0 )); then

	(( ++N ));


# For timing purposes, wait until all subprocesses are complete



For the price, the Wolverine Titan appears to be the best choice for scanning in film negatives.  The device itself is easy to use and pretty efficient for scanning large numbers of negatives.  Image quality ranges from “acceptable” to “pretty good” once you perform some rather tedious pre-processing.


As for alternatives, more expensive solutions like flatbed scanners with transparency/negative modes may give better results.  Cheaper solutions typically just provide a light table and use your phone camera as the scanner.  Those will almost certainly provide worse results.  (For example, a 35 mm film negative at the minimum distance needed to focus from your cell phone camera is just too small to provide decent resolution.)  An intriguing solution that could give good results may be to make some kind of rig to hold the negatives in front of a light source and then take pictures with a digital camera using a macro lens.  I might try that if I get a minute.


Thanks for reading!  Get out there and take some pictures. 


By Rocky Scaletta.  © 2021.