Imago

Imago is an image manipulation library for Common Lisp. It supports images in png, portable bitmap (.pnm), Truevision TGA (.tga), jpeg, TIFF and HEIC formats. You can read an image with imago:read-image and write an image with imago:write-image, a correct image format will be automatically determined from the image extension.

Dependencies

Some file formats require additional dependencies. Support for these formats are split into separate systems:

Format	System	Dependency	I/O functions
HEIC	imago/libheif	libheif	imago/libheif:read-heic & imago/libheif:write-heic
jpeg	imago/jpeg-turbo	libturbojpeg	imago/jpeg-turbo:read-jpeg & imago/jpeg-turbo:write-jpeg
TIFF	imago/libtiff	libtiff	imago/libtiff:read-tiff & imago/libtiff:wite-tiff

You can also read and write images of these formats with imago:read-image and imago:write-image once a suitable system is loaded. JPEG files can be read and written without imago/jpeg-turbo, but the latter option is much more reliable.

Creating an image

To create an image look at the documentation for image classes (like imago:rgb-image or imago:grayscale-image). You need to make an instance of one of those classes by passing :w, :h and optionally :initial-color keyword arguments to make-instance. Alternatively, you can use make-XXX-image and make-XXX-image-from-pixels functions:

;; Create 100x100 px black grayscale image
(imago:make-grayscale-image 100 100)

;; Create 400x100 px red RGB image
(imago:make-rgb-image 400 100 (imago:make-color 255 0 0))

;; Create 400x100 px half-transparent red RGB image
(imago:make-rgb-image 400 100 (imago:make-color 255 0 0 127))

;; Create an image from an array of pixels
(imago:make-rgb-image-from-pixels
 (make-array '(100 100)
             :element-type 'imago:rgb-pixel
             :initial-element (imago:make-color 0 255 255)))

Usage examples

Most of the examples are taken from here.

Resizing an image

(resize *image* 400 150)

Original	Processed

Rotating an image

(rotate *image* 45)

Original	Processed

Applying an emboss effect

(emboss *image* :angle (* pi 0.75) :depth 1.0)

Original	Processed

Using a custom convolution kernel

(let ((kernel #2A((0  0  0  0  0)
                  (0  0  1  0  0)
                  (0  1 -4  1  0)
                  (0  0  1  0  0)
                  (0  0  0  0  0))))
  (convolve *image* kernel 1 0))

Original	Processed

Inverting a rectangular region

(do-region-pixels (*image* color x y 70 65 140 125)
  (setf color (invert-color color)))

Original	Processed

Adjusting contrast of a grayscale image

(enhance-contrast *grayscale-image*)

Original	Processed

Manipulating color components

(do-image-pixels (*image* color x y)
  (multiple-value-bind (r g b) (color-rgba color)
    (setf color (make-color b
                            (floor (* g 0.8))
                            r))))

Original	Processed

Composing pictures

(let ((operator (default-compose-operator *image1*)))
  (compose nil *image1* *image2* 20 20 operator))

Original 1	Original 2	Processed

Drawing simple primitives

(let ((points '(83 45 73 150 73 150 198 106 198 106 83 45)))
  (draw-polygon *image* points +white+ :closed t))
(draw-circle *image* 83 45 15 +white+)
(draw-circle *image* 73 150 15 +white+)
(draw-circle *image* 198 106 15 +white+)
(draw-bezier-curve *image* 10 80 150 60 100 170 200 170 +red+)
(draw-line *image* 0 5 254 5 +yellow+)
(draw-line *image* 0 10 254 10 +yellow+ :dash-length 1 :dash-interval 1)
(draw-line *image* 0 15 254 15 +yellow+ :dash-length 4 :dash-interval 2)

Original	Processed

A more complex example

(defun sea-view (image)
  (let ((image2 (flip nil image :horizontal)))
    (do-image-pixels (image2 color x y)
      (multiple-value-bind (r g b)
          (color-rgba color)
        (setf color (make-color (floor r 3) (floor g 3) (floor b 2)))))
    (let* ((width (image-width image))
           (height (image-height image))
           (result (make-instance (class-of image)
                                  :width width :height (* height 2))))
      (copy result image)
      (copy result image2 :dest-y height)
      result)))

Original	Processed

Connected components labeling

This example requires snakes and array-operations systems (available in quicklisp).

(defpackage components-example
  (:use #:cl
        #:snakes
        #:imago)
  (:export #:convert-to-image))
(in-package :components-example)

(defgenerator generate-colors ()
  (loop while t do
    (yield (make-color (random 256)
                       (random 256)
                       (random 256)))))

(defgenerator black ()
  (yield (make-color 0 0 0)))

(defun convert-to-image (components)
  (declare (type (simple-array fixnum (* *)) components))
  (let ((colors (take (1+ (reduce #'max (aops:flatten components)))
                      (chain (black)
                             (generate-colors))))
        (image (make-array (array-dimensions components)
                           :element-type 'rgb-pixel)))
    (array-operations/utilities:nested-loop (i j)
        (array-dimensions components)
      (setf (aref image i j)
            (nth (aref components i j) colors)))
    (make-instance 'rgb-image :pixels image)))

(in-package :cl-user)
(let* ((image (imago:read-image "~/.quicklisp/local-projects/imago/tests/spheres.png"))
       (components (imago:label-components (imago:convert-to-binary image 1))))
  (components-example:convert-to-image components))

Original	Processed

Distance transform

Calculating squared Euclidean distance transform (also Manhattan distance transform is available). This example requires array-operations.

(defun edt-image (image)
  (declare (type imago:binary-image image))
  (let* ((dt (imago:distance-transform image :type :edt))
         (max (reduce #'max (aops:flatten dt)))
         (pixels (make-array (array-dimensions dt) :element-type 'imago:grayscale-pixel)))
    (map-into (aops:flatten pixels)
              (lambda (x) (imago:make-gray (floor (* 255 x) max)))
              (aops:flatten dt))
    (make-instance 'imago:grayscale-image :pixels pixels)))

(edt-image original-image)

Original	Processed

Intergation with common-lisp-jupyter

You can view imago images in Jupyter by installing imago/jupyter system. Then call imago/jupyter:show-image function to show an image.