Merge pull request #10 from phoe-trash/master

Add image composition, VECTO-IMAGO contrib, custom allocators and returning images

Author: xach

doc/index.html

@@ -65,6 +65,7 @@ <h3>Contents</h3>
     <ul>
       <li> <a href='#with-canvas'><tt>with-canvas</tt></a>
       <li> <a href='#clear-canvas'><tt>clear-canvas</tt></a>
+      <li> <a href='#compose'><tt>compose</tt></a>
       <li> <a href='#save-png'><tt>save-png</tt></a>
       <li> <a href='#save-png-stream'><tt>save-png-stream</tt></a>
     </ul>
@@ -304,13 +305,33 @@ <h3>Contents</h3>
 <a name='sect-canvases'><h4>Canvases</h4></a>
 
 <p><a name='with-canvas'>[Macro]</a><br>
-<b>with-canvas</b> (<tt>&amp;key</tt> <i>width</i> <i>height</i>)
-<tt>&amp;body</tt> <i>body</i>
+<b>with-canvas</b> (<tt>&amp;key</tt> <i>width</i> <i>height</i>
+<i>image-data-allocator</i>) <tt>&amp;body</tt> <i>body</i>
 
 <blockquote>
 Evaluates <i>body</i> with a canvas established with the specified
 dimensions as the target for drawing commands. The canvas is initially
 completely clear (all pixels have 0 alpha).
+
+It is possible to provide a one-argument function to the
+<i>image-data-allocator</i> argument. That function will be called with
+one argument (the size of the resulting vector) and must return a vector
+of <i>(unsigned-byte 8)</i> which will be used as storage for the image
+data. This is useful e.g. for using a
+<a href='https://github.com/sionescu/static-vectors'>static vector</a>
+for the storage in order to make the resulting PNG data interoperable
+with foreign libraries:
+
+<pre><img style='float: right' class='transparent'
+          src='linear-gradient.png'>(flet ((allocate (size)
+         (static-vectors:make-static-vector size :initial-element 0)))
+  (with-canvas (:width ... :height ...
+                :image-data-allocator #'allocate)
+    ...))
+</pre>
+
+Also see <a href='#zpng-object'><tt>ZPNG-OBJECT</tt></a>.
+
 </blockquote>
 
 
@@ -323,6 +344,24 @@ <h3>Contents</h3>
 </blockquote>
 
 
+<p><a name='compose'>[Generic Function]</a><br>
+<b>compose</b> <i>layer</i> <i>x</i> <i>y</i> => |
+
+<blockquote>
+Performs image composition by superimposing <i>image</i> on top of the
+current canvas, relative to the coordinate center of the image.
+
+<b>This composition disregards all transformations done to the image's
+coordinate system other than translations - so, skewing, rotations, etc..</b>
+Use systems that manipulate raster graphics (such as
+<a href='https://common-lisp.net/project/imago/'>Imago</a>) to adjust
+the raster image before compositing it with Vecto.
+
+This GF has no default implementations and is meant to be implemented
+by users.
+</blockquote>
+
+
 <p><a name='save-png'>[Function]</a><br>
 <b>save-png</b> <i>file</i> => <i>truename</i>
 
@@ -341,6 +380,13 @@ <h3>Contents</h3>
 </blockquote>
 
 
+<p><a name='zpng-object'>[Function]</a><br>
+<b>zpng-object</b> => <i>png</i>
+
+<blockquote>
+Returns the ZPNG object representing the canvas.
+</blockquote>
+
 <a name='sect-graphics-state'><h4>Graphics State</h4></a>
 
 <p>The graphics state stores several parameters used for graphic

graphics-state.lisp

@@ -155,19 +155,27 @@ with the result of premultiplying it with MATRIX.")
 (defmethod (setf paths) :after (new-value (state graphics-state))
   (setf (path state) (first new-value)))
 
-(defun state-image (state width height)
+(defun state-image (state width height &optional image-data-allocator)
   "Set the backing image of the graphics state to an image of the
 specified dimensions."
   (setf (image state)
-        (make-instance 'zpng:png
-                       :width width
-                       :height height
-                       :color-type +png-color-type+)
+        (if image-data-allocator
+            (make-instance 'zpng:png
+                           :width width
+                           :height height
+                           :color-type +png-color-type+
+                           :image-data (let ((samples (zpng:samples-per-pixel
+                                                       +png-color-type+)))
+                                         (funcall image-data-allocator
+                                                  (* width height samples))))
+            (make-instance 'zpng:png
+                           :width width
+                           :height height
+                           :color-type +png-color-type+))
         (width state) width
         (height state) height
         (clipping-path state) (make-clipping-path width height))
   (apply-matrix state (translation-matrix 0 (- height))))
-  
 
 (defun find-font-loader (state file)
   (let* ((cache (font-loaders state))

package.lisp

@@ -41,6 +41,7 @@
    #:clear-canvas
    #:save-png
    #:save-png-stream
+   #:zpng-object
    ;; path construction
    #:move-to
    #:line-to
@@ -83,6 +84,8 @@
    #:bilinear-domain
    #:cartesian-coordinates
    #:polar-coordinates
+   ;; generic functions for handling foreign images
+   #:compose
    ;; graphics state coordinate transforms
    #:translate
    #:rotate

user-drawing.lisp

@@ -325,15 +325,22 @@ through one control point."
 (defun rotate-degrees (degrees)
   (%rotate *graphics-state* (* (/ pi 180) degrees)))
 
+(defgeneric compose (layer x y))
+
 (defun save-png (file)
   (zpng:write-png (image *graphics-state*) file))
 
 (defun save-png-stream (stream)
   (zpng:write-png-stream (image *graphics-state*) stream))
 
-(defmacro with-canvas ((&key width height) &body body)
+(defun zpng-object ()
+  (image *graphics-state*))
+
+(defmacro with-canvas ((&key width height image-data-allocator)
+                       &body body)
   `(let ((*graphics-state* (make-instance 'graphics-state)))
-     (state-image *graphics-state* ,width ,height)
+     (state-image *graphics-state* ,width ,height
+                  ,@(when image-data-allocator `(,image-data-allocator)))
      (unwind-protect
           (progn
             ,@body)

vecto-imago/vecto-imago.asd

@@ -0,0 +1,34 @@
+;;; Copyright (c) 2007 Michał "phoe" Herda, All Rights Reserved
+;;;
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+;;;
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+;;;
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+;;;
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(asdf:defsystem #:vecto-imago
+  :depends-on (#:vecto #:imago)
+  :version "1.0"
+  :author "Michał \"phoe\" Herda <[email protected]>"
+  :description "Utilities for Imago and Vecto interoperability."
+  :license "BSD"
+  :components ((:file "vecto-imago")))
+

vecto-imago/vecto-imago.lisp

@@ -0,0 +1,89 @@
+(defpackage #:vecto-imago
+  (:use #:cl)
+  (:local-nicknames (#:v #:vecto) (#:i #:imago) (#:z #:zpng)))
+
+(in-package #:vecto-imago)
+
+(declaim (inline blend-alpha))
+(defun blend-alpha (src-a dest-a)
+  (declare (optimize speed))
+  (declare (type (unsigned-byte 8) src-a dest-a))
+  (let* ((src-a (* 1f0 1/255 src-a))
+         (dest-a (* 1f0 1/255 dest-a))
+         (result (+ src-a (* dest-a (- 1f0 src-a)))))
+    (round (* result 255f0))))
+
+(declaim (inline blend))
+(defun blend (ca cb aa ab ar)
+  (declare (optimize speed))
+  (declare (type (unsigned-byte 8) ca cb aa ab ar))
+  (cond ((= 0 aa) cb)
+        ((= 0 ab) ca)
+        (t (let* ((aa (* 1f0 1/255 aa))
+                  (ab (* 1f0 1/255 ab))
+                  (ar (* 1f0 1/255 ar)))
+             (let* ((left (* ca aa))
+                    (right (* cb ab (- 1f0 aa)))
+                    (result (/ (+ left right) ar)))
+               (declare (type (single-float 0f0 255f0) left right result))
+               (round result))))))
+
+(deftype png-image-dimension () '(unsigned-byte 31))
+
+(defmethod v:compose ((layer imago:rgb-image) x-offset y-offset)
+  (declare (optimize speed))
+  (declare (type (signed-byte 32) x-offset y-offset))
+  (let* ((src (imago:image-pixels layer))
+         (zpng (v:zpng-object))
+         (dest (zpng:image-data zpng)))
+    (declare (type (simple-array imago:rgb-pixel (* *)) src))
+    (declare (type (simple-array (unsigned-byte 8) (*)) dest))
+    (destructuring-bind (src-height src-width) (array-dimensions src)
+      (declare (type png-image-dimension src-height src-width))
+      (let* ((dest-height (z:height zpng))
+             (dest-width (z:width zpng))
+             ;; TODO: stop being ugly here, write a reader function in vecto
+             ;; which returns the transform matrix
+             ;; and then export accessor functions for it
+             (matrix (v::transform-matrix v::*graphics-state*))
+             (matrix-x-offset (ceiling
+                               (the (single-float 0f0 #.(* (ash 1 31) 1f0))
+                                    (v::transform-matrix-x-offset matrix))))
+             (matrix-y-offset (ceiling
+                               (the (single-float 0f0 #.(* (ash 1 31) 1f0))
+                                    (v::transform-matrix-y-offset matrix))))
+             (x-offset (+ matrix-x-offset x-offset))
+             (y-offset (- matrix-y-offset y-offset src-height)))
+        (declare (type png-image-dimension dest-height dest-width))
+        (dotimes (src-y src-height)
+          (dotimes (src-x src-width)
+            (let ((dest-y (+ src-y y-offset))
+                  (dest-x (+ src-x x-offset)))
+              (declare (type (signed-byte 32) dest-x dest-x))
+              (when (and (<= 0 dest-y (1- dest-height))
+                         (<= 0 dest-x (1- dest-width)))
+                (let* ((src-color (aref src src-y src-x))
+                       (src-a (i:color-alpha src-color))
+                       (src-r (i:color-red src-color))
+                       (src-g (i:color-green src-color))
+                       (src-b (i:color-blue src-color))
+                       (dest-y-offset (* dest-y dest-width))
+                       (dest-xy-offset (+ dest-y-offset dest-x))
+                       (dest-offset (* (the (unsigned-byte 8)
+                                            (z:samples-per-pixel zpng))
+                                       dest-xy-offset))
+                       (dest-a (aref dest (+ dest-offset 3)))
+                       (dest-b (aref dest (+ dest-offset 2)))
+                       (dest-g (aref dest (+ dest-offset 1)))
+                       (dest-r (aref dest (+ dest-offset 0))))
+                  (declare (type png-image-dimension
+                                 dest-y-offset dest-offset))
+                  (unless (= src-a 0)
+                    (let* ((a (blend-alpha src-a dest-a))
+                           (r (blend src-r dest-r src-a dest-a a))
+                           (g (blend src-g dest-g src-a dest-a a))
+                           (b (blend src-b dest-b src-a dest-a a)))
+                      (setf (aref dest (+ dest-offset 3)) a
+                            (aref dest (+ dest-offset 2)) b
+                            (aref dest (+ dest-offset 1)) g
+                            (aref dest (+ dest-offset 0)) r))))))))))))