Using Script-Fu in the GNU Image Manipulation Program to Automate Smart

Sharpening
Benjamin Bucior
Summer Ventures 2007
Appalachian State University
Abstract
The GNU Image Manipulation Program, commonly abbreviated as the Gimp, is a free,
open-source image editing program. Many photo restoration techniques exist to enhance
images by making them clearer. This project focused on automating a powerful, yet
complicated, method called smart sharpening. To accomplish this, a script was written
in the Gimps Script-Fu language. After completion of the script, smart sharpening
was compared to similar image sharpening procedures to evaluate its effectiveness.
Despite surprising results on some types of images, more research is needed to further
improve the script.
Introduction
The GNU Image Manipulation Program, commonly abbreviated as the Gimp, is a free,
open-source image editing program similar to Adobe Photoshop. A default installation of
the Gimp includes filters for common photo restoration tasks, including edge detection,
matrix convolution, Gaussian blurs, and sharpening. The Gimp also has support for
channels and layers, allowing for advanced blending and delicate drawing on images.
Digital cameras have progressively become more advanced, but many still blur
photographs during capture and compression. To repair this damage, several algorithms
exist to sharpen images. The simplest of these, called convolution, uses a matrix to
replace the value of each pixel. The center of the matrix represents the modified point,
and surrounding pixels are multiplied by their corresponding factors in the matrix. These
products are added together to create the replacement value for the center pixel. Another
method to sharpen pictures, called unsharp masking, combines the original image and a
smoothed version to enhance edges [1].
Smart sharpening is a process that sharpens the image without increasing image
noise. Instead of applying a uniform filter across the image, it focuses on the edges of the
image and avoids changing its colors [2]. First, the procedure duplicates the image and
extracts the Value channel from the HSV (Hue Saturation Value) decomposition of
brightness levels. A sharpening layer is created on the original image by copying the
Value channel. An edge detection algorithm is passed over the duplicate image, which
is further filtered by modifying light levels and blurring the result. This becomes the
edge mask that is added to the sharpening layer. An unsharp mask on this sharpening
layer creates the final product, a clearer image than the original.
Most photo restoration techniques can be automated by scripting in the Gimps
Script-Fu programming language. The SOID (Scheme in One Defun) interpreter for
Script-Fu allows for cross-platform development of such tools by providing a simple
interface to the Gimps functions [3]. Automation of common tasks reduces repetition,
saves time, decreases the chance of human error, and simplifies processes by combining
steps into one central command. This project will focus on the development of a script to
automate the smart sharpening algorithm. After the program is completed, the smart
sharpening technique will be compared to similar methods of photo sharpening to
compare their effectiveness on enhancing images.

Methods
Online tutorials were helpful in gathering background knowledge about photo restoration
techniques. The smart sharpening technique created by Eric Jeschke was chosen for
this project because of its complexity and remarkable results [2]. The Gimp was chosen
for image processing because of its cross-platform compatibility, functionality, and
support for scripting. At first, the smart sharpening technique was going to be
programmed in Perl using the Gimp::Fu module. However, limitations against using Perl
in Windows XP encouraged development in Scheme. Only Linux builds of the Perl
module were available. In addition, installation of the smart sharpening script was
easier without the prerequisite of the Perl interpreter. Although the syntax of Scheme
was challenging at first, programming in Script-Fu did not require knowledge of all of
Schemes functions. The Procedure Browser in the Gimp aided development by listing
every function with a brief description and the required parameters.
Besides the Gimp, the only other program required for creating the script was a
basic text editor. This project used Notepad++ Portable in Windows and the KDE
Advanced Text Editor (Kate) in Linux to write the script because of their syntax-
highlighting support. However, no specific text editor was required to program in Script-
Fu, provided that it could save with the .scm extension. While coding, it was helpful to
keep the Gimp open to debug each line and ensure that it preformed its intended function.
For testing and installation, the script was saved as smart-sharpen.scm in the Gimps
scripts folder. The location of this scripts folder varied but could always be found by
going to File>Preferences>Folders>Scripts in the Gimp.
Some peculiarities of the Gimps Script-Fu language made coding more difficult.
Gimp plug-ins written in C and the Procedure Browser listed functions with underscores,
but Script-Fu required them to have dashes instead. Gimp functions always returned
values as single-item lists, so the car function was required when setting variables [4].
Additionally, using Schemes prefix notation inside of nested parenthesis [5] caused
problems when commands were coded as func(arg1) instead of (func arg1). Several
parameters [6] were added to the script-fu-register procedure to create user interactivity
with the script. In addition, a list after each variables description set the default values
and checked the validity of parameters passed to the script [7].
The scripts final source code is as follows:
(define (script-fu-smart-sharpen img1
draw1
edge_amt
gmin1
gmax1
blur_amt
gmin2
gmax2
umask_radius
umask_amt
umask_threshold
)
;Start script with define and enclose everything as local variable
(gimp-image-undo-group-start img1)
(let* (
;Duplicate img1 to img2
(img2 (car (gimp-image-duplicate img1)))
;;(display2 (car (gimp-display-new img2)))
;Get var name of layer on img2, for later usage in edge detection
(draw2 (car (gimp-image-get-active-drawable img2)))

;Decompose original image to value channel of HSV
(img3 (car (plug-in-decompose 1 img1 draw1 "Value" 1)))
;;(display3 (car (gimp-display-new img3)))

;;(OLD)Create new layer called sharpening, replaced with layer-copy
;;(sharpening (car (gimp-layer-new img1 (car (gimp-image-width img1))
(car (gimp-image-height img1)) 0 "sharpening" 100 0)))
;Duplicate original layer to "sharpening" layer
(sharpening (car (gimp-layer-copy draw1 0)))
)

;Now all var declarations must be called with (set! varname value)
(gimp-image-add-layer img1 sharpening 0)
(gimp-drawable-set-name sharpening "Sharpening")
;Add alpha channel to Sharpening layer for mask later
(gimp-layer-add-alpha sharpening)

;Copy and anchor Value image to Sharpening Layer
(gimp-image-set-active-layer img1 sharpening)
(gimp-selection-all img3)
(gimp-edit-copy-visible img3)
(set! value_float (car (gimp-edit-paste sharpening 0)))
(gimp-floating-sel-anchor value_float)
;Clear the selected area on the Values image
(gimp-selection-none img3)

;Set Sharpening blending mode to "Value"
(gimp-layer-set-mode sharpening 14)

;Now to create the edge mask :)
;Edge Detection and conversion to grayscale
(plug-in-edge 1 img2 draw2 edge_amt 1 0)
(gimp-image-convert-grayscale img2)

;Adjust mask by filtering insignificant edges
;Change black/white points, apply gaussian blur, and redo change levels
(gimp-levels draw2 0 gmin1 gmax1 1 0 255)
(plug-in-gauss 1 img2 draw2 blur_amt blur_amt 0)
(gimp-levels draw2 0 gmin2 gmax2 1 0 255)

;Add white mask to Sharpening layer
(set! sh_mask (car (gimp-layer-create-mask sharpening 0)))
(gimp-layer-add-mask sharpening sh_mask)

;Add and anchor edge mask image to Sharpening layer
;Yay for reusable code!
(gimp-selection-all img2)
(gimp-edit-copy-visible img2)
(set! value_float (car (gimp-edit-paste sh_mask 0)))
(gimp-floating-sel-anchor value_float)
(gimp-selection-none img2)

;Apply final unsharp mask
;;(gimp-image-set-active-channel img1 sh_mask)
(plug-in-unsharp-mask 1 img1 sharpening umask_radius umask_amt
umask_threshold)

;Remove file close confirmation for temp images, refresh displays,
complete undo group
(gimp-image-clean-all img2)
(gimp-image-clean-all img3)
(gimp-displays-flush)
)
(gimp-image-undo-group-end img1)
)

;Variable Parenthesis after name:
;(default, min, max, small_inc, big_inc, precision, slider(0)/entry(1))
(script-fu-register "script-fu-smart-sharpen"
_"Smart _Sharpening..."
"Sharpens an image without increasing film grain.\nBased on the
tutorial at\nhttp://gimpguru.org/Tutorials/SmartSharpening2/"
"Benjamin Bucior <ben.bucior@gmail.com>"
"Benjamin Bucior"
"2007-07-19"
"RGB*"
SF-IMAGE "Image" 0
SF-DRAWABLE "Drawable" 0
SF-ADJUSTMENT _"Amount of Edge Detection" '(6 1 10 .1 1 1 0)
SF-ADJUSTMENT _"Mask's Grayscale Min Before Blur" '(20 1 100 1 10 0 0)
SF-ADJUSTMENT _"Mask's Grayscale Max Before Blur" '(235 155 255 1 10 0
0)
SF-ADJUSTMENT _"Mask's Gaussian Blur Amount" '(5 1 15 1 5 0 0)
SF-ADJUSTMENT _"Mask's Grayscale Min After Blur" '(10 1 100 1 10 0 0)
SF-ADJUSTMENT _"Mask's Grayscale Max After Blur" '(235 155 255 1 10 0 0)
SF-ADJUSTMENT _"Unsharp Mask Radius" '(1 .1 120 .1 1 1 0)
SF-ADJUSTMENT _"Unsharp Mask Amount" '(2 0 5 .01 .1 2 0)
SF-ADJUSTMENT _"Unsharp Mask Threshold" '(0 0 255 1 10 0 0)
)

(script-fu-menu-register "script-fu-smart-sharpen" "<Image>/Script-
Fu/Alchemy")
The effectiveness of the technique was tested by comparing the results of the
filters on the same image. The original testing image was an unmodified photo from a
digital camera. Convolution filtering was tested by using Filters>Generic>Convolution
Matrix with a standard matrix [Figure 1]; red, green, and blue channels enabled; and an
extended border [8]. Unsharp masking was evaluated by using Filters>Enhance>Unsharp
Mask with the default radius of 5.0, amount of 0.5, and threshold of 1. Smart
sharpening was given the default parameters in the script to maintain consistency among
results.

[Figure 1: Tested convolution matrix]


Results
Zoomed sections of each enhanced image were analyzed to determine the effectiveness of
each filter. The original image [Figure 2] without enhancement was more blurred than
the others and had the softest colors. The convolution matrix filtering [Figure 3]
sharpened the photo too broadly, causing noise in the picture to become worse. The
unsharp mask [Figure 4] enhanced edges in the image without modifying the color of the
images objects. Smart sharpening [Figure 5] enhanced the photo while increasing
contrast between colors, but many soft edges became more jagged. The smart
sharpening script greatly decreased processing time on the images. Instead of taking over
20 minutes to manually complete the tutorial, the script sharpened the image in less than
30 seconds.
[Figure 2: Original Image] [Figure 3: Convolution Matrix]


[Figure 4: Unsharp Mask] [Figure 5: Smart Sharpening]


Conclusion
Of the three tested sharpening filters, smart sharpening and unsharp mask filtering
enhanced digital photos the best. Smart sharpening seemed to increase contrast in the
image since it applied filters to light levels, but some of these changes to object color in
the image made the image appear more artificial. The edge detection used in smart
sharpening made many lines in the final image appear jagged. This problem is
commonly solved by anti-aliasing, a process that would make the image less sharp.
Smart sharpening best enhanced photographs at plants. The technique also fixed small
amounts of blur but failed to remove the heavy blurring commonly caused by taking
photographs in darker environments.
Script-Fu was a simple programming language to learn. The entire process of
creating the script, from first learning Schemes syntax to finishing the final product, took
less than 5 days. Scripting significantly reduced image processing time and could be
used to automate other common tasks, such as red-eye removal, image noise reduction,
and blurring correction.
Tweaking the parameters passed to each filter also changed the effectiveness of
image enhancement. Convolution matrices could have been used to do many types of
filtering, including sharpening, blurring, embossing, and edge detection [8]. The unsharp
mask performed best with large radius values and smaller strengths. Results from the
smart sharpening filter varied based on the image. Each image required different
parameters to produce an optimized product because of the complexity of the smart
sharpening algorithm.
In the future, the script could be improved upon and expanded. Since image
processing is mainly based on human preference, no predetermined algorithm could ever
produce a perfected image. However, several extensions could be added to the script to
make it more useful. In addition to the current automatic mode, the script could include a
more guided approach to apply the smart sharpening filter. Based on the appearance of
the image after every step, the user would increase or decrease the amount of sharpening
required. The script could also be given a command line mode to allow batch processing
of images. In order to be a more effective filter, the script should also have better default
values. Currently, parameters passed to the script are estimated figures, but averaging
optimized values from several photos would produce better default parameters. More
testing with the script could also eventually lead to the creation of a larger, generalized
photo restoration script that would do several filters, including red-eye removal, before
creating the finalized result.
References
[1] HIPR2, http://homepages.inf.ed.ac.uk/rbf/HIPR2/unsharp.htm
[2] Eric R. Jeschke, http://gimpguru.org/Tutorials/SmartSharpening2/
[3] Simon Budig, http://gimp.org/docs/scheme_plugin/scheme-overview.html
[4] Dov Grobgeld, http://gimp.org/tutorials/Basic_Scheme/
[5] John Beppu, http://gimp.org/tutorials/Basic_Scheme2/
[6] Michael Terry, http://www.klaban.torun.pl/help/script-fu-tutorial/
[7] Simon Budig, http://gimp.org/docs/scheme_plugin/script-fu-gimp.html
[8] The Gimp Documentation Team, http://docs.gimp.org/en/plug-in-convmatrix.html