imago
1.0.0
Imago ist eine Bildmanipulationsbibliothek für gemeinsames Lisp. Es unterstützt Bilder in PNG-, PCX-, tragbaren Bitmap (.PNM), TrueVision TGA (.tgA) und JPEG -Formaten. Sie können ein Bild mit imago:read-image lesen und ein Bild mit imago:write-format schreiben, wobei format eines von png , pcx , pnm , tga oder jpg ist.
Sie können eine fortgeschrittenere Bibliothek für die Bibliothek für die libjpeg-turbo verwenden, um mit JPEG-Dateien zu handeln, indem Sie imago/jpeg-turbo -System laden. Stellen Sie sicher, dass libjpeg-turbo auf Ihrem System installiert ist. Verwenden Sie imago-jpeg-turbo:read-jpg-turbo und imago-jpeg-turbo:write-jpg-turbo Funktionen (oder nur imago:read-image und imago:write-image ), um diese Funktionalität zu verwenden.
Sie können eine fortgeschrittenere und schnellere PNGLOAD -Bibliothek verwenden, um PNG -Dateien durch das Laden imago/pngio -Systemen zu lesen. Verwenden Sie imago-pngio:read-png (oder nur imago:read-image ), um diese Funktionalität zu verwenden. NB: pngload wandelt automatisch indizierte Farbbilder in RGB (oder ARGB) -Bilder um. Wenn Sie mit indizierten Bildern arbeiten möchten, verwenden Sie stattdessen einen alten PNG -Loader. Auch ZPNG (über imago-pngio:write-png ) wird zur Speichern von PNG-Bildern verwendet.
So erstellen Sie einen Image-Blick auf die Dokumentation für Bildklassen (wie imago:rgb-image oder imago:grayscale-image ). Sie müssen eine Instanz einer dieser Klassen erstellen, indem Sie bestanden :w :h und optional :initial-color Keyword-Argumente für make-instance . Alternativ können Sie make-XXX-image und make-XXX-image-from-pixels Funktionen verwenden:
;; 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)))
Die meisten Beispiele werden von hier aus genommen.
(resize *image* 400 150)
| Original | Verarbeitet |
|---|---|
 |  |
(rotate *image* 45)
| Original | Verarbeitet |
|---|---|
 |  |
(emboss *image* :angle (* pi 0.75) :depth 1.0)
| Original | Verarbeitet |
|---|---|
 |  |
(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 | Verarbeitet |
|---|---|
 |  |
(do-region-pixels (*image* color x y 70 65 140 125)
(setf color (invert-color color)))
| Original | Verarbeitet |
|---|---|
 |  |
(enhance-contrast *grayscale-image*)
| Original | Verarbeitet |
|---|---|
 |  |
(do-image-pixels (*image* color x y)
(multiple-value-bind (r g b) (color-rgb color)
(setf color (make-color b
(floor (* g 0.8))
r))))
| Original | Verarbeitet |
|---|---|
 |  |
(let ((operator (default-compose-operator *image1*)))
(compose nil *image1* *image2* 20 20 operator))
| Original 1 | Original 2 | Verarbeitet |
|---|---|---|
 |  |  |
(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 | Verarbeitet |
|---|---|
 |  |
(defun sea-view (image)
(let ((image2 (flip nil image :horizontal)))
(do-image-pixels (image2 color x y)
(multiple-value-bind (r g b)
(color-rgb 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 | Verarbeitet |
|---|---|
 |  |
Dieses Beispiel erfordert Schlangen und Array-Operations-Systeme (in QuickLisp verfügbar).
(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 | Verarbeitet |
|---|---|
 |  |
Berechnung der quadratischen euklidischen Distanztransformation (auch Manhattan -Distanztransformation ist verfügbar). Dieses Beispiel erfordert 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 | Verarbeitet |
|---|---|
 |  |
Sie können Imago -Bilder in Jupyter anzeigen, indem Sie imago/jupyter -System installieren. Rufen Sie dann imago-jupyter:show-image Funktion auf, um ein Bild anzuzeigen.
