imago
1.0.0
IMelo es una biblioteca de manipulación de imágenes para LISP común. Admite imágenes en PNG, PCX, mapa de bits portátil (.pnm), trueVision TGA (.tga) y JPEG en formatos. Puede leer una imagen con imago:read-image y escribir una imagen con imago:write-format donde format es uno de png , pcx , pnm , tga o jpg .
Puede usar la biblioteca libjpeg-turbo más avanzada para tratar los archivos JPEG cargando el sistema imago/jpeg-turbo . Asegúrese de que libjpeg-turbo esté instalado en su sistema. Use imago-jpeg-turbo:read-jpg-turbo e imago-jpeg-turbo:write-jpg-turbo Functions (o simplemente imago:read-image e imago:write-image ) para usar esta funcionalidad.
Puede usar la biblioteca PNGLOAD más avanzada y más rápida para leer archivos PNG cargando el sistema imago/pngio . Use imago-pngio:read-png (o simplemente imago:read-image ) para usar esta funcionalidad. NB: pngload convierte automáticamente imágenes en color indexadas en imágenes RGB (o Argb). Si desea trabajar con imágenes indexadas, use un cargador PNG antiguo en su lugar. También se utilizará la biblioteca ZPNG (a través de imago-pngio:write-png ) para guardar imágenes PNG.
Para crear una imagen, mire la documentación para las clases de imagen (como imago:rgb-image o imago:grayscale-image ). Debe hacer una instancia de una de esas clases pasando :w ,: :h y opcionalmente :initial-color a make-instance . Alternativamente, puede usar funciones make-XXX-image y make-XXX-image-from-pixels :
;; 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)))
La mayoría de los ejemplos se toman desde aquí.
(resize *image* 400 150)
| Original | Procesado |
|---|---|
 |  |
(rotate *image* 45)
| Original | Procesado |
|---|---|
 |  |
(emboss *image* :angle (* pi 0.75) :depth 1.0)
| Original | Procesado |
|---|---|
 |  |
(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 | Procesado |
|---|---|
 |  |
(do-region-pixels (*image* color x y 70 65 140 125)
(setf color (invert-color color)))
| Original | Procesado |
|---|---|
 |  |
(enhance-contrast *grayscale-image*)
| Original | Procesado |
|---|---|
 |  |
(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 | Procesado |
|---|---|
 |  |
(let ((operator (default-compose-operator *image1*)))
(compose nil *image1* *image2* 20 20 operator))
| Original 1 | Original 2 | Procesado |
|---|---|---|
 |  |  |
(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 | Procesado |
|---|---|
 |  |
(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 | Procesado |
|---|---|
 |  |
Este ejemplo requiere serpientes y sistemas de operaciones de matriz (disponibles en rápida).
(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 | Procesado |
|---|---|
 |  |
Calculación de transformación de distancia euclidiana al calcular (también está disponible la transformación de distancia de Manhattan). Este ejemplo requiere 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 | Procesado |
|---|---|
 |  |
Puede ver imágenes de Imelo en Jupyter instalando el sistema imago/jupyter . Luego llame imago-jupyter:show-image para mostrar una imagen.
