bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#11431: 24.1.50; [PATCH] Implement fit-to-width/height for rotated im


From: Wolfgang Jenkner
Subject: bug#11431: 24.1.50; [PATCH] Implement fit-to-width/height for rotated images
Date: Tue, 08 May 2012 01:37:42 +0200
User-agent: Gnus/5.130006 (Ma Gnus v0.6) Emacs/24.1.50 (berkeley-unix)

This takes care of a TODO in image-mode, viz. "fit-to-* should consider
the rotation angle".  So, evaluating something like

(progn
  (image-transform-fit-to-width)
  (image-transform-set-rotation 42))

in the image-mode buffer (with ImageMagick) should work as expected.

The problem is to scale the image so that the bounding box of the
rotated image will have the width/height of the window.  This turns out
to be quite an interesting exercise because of the way ImageMagick
adjusts geometry to compute this bounding box, which makes it also
possible to /exactly/ meet the given width/height.  Please, see the
source code comments below.

Note that the (trivial) patch of

bug#11399: 24.1.50; [PATCH] image-mode scaling fix

has to be applied before this one.

2012-05-06  Wolfgang Jenkner  <address@hidden>

        Implement fit-to-width/height for rotated images.

        * image-mode.el (image-transform-scale)
        (image-transform-right-angle-fudge): New vars.
        (image-transform-width, image-transform-fit-width): New functions.
        (image-transform-properties): Use them.
        (image-transform-check-size): New function.
        (image-toggle-display-image): Use it (for testing).
        (image-transform-set-rotation): Reduce angle mod 360.  Delete
        obsolete comment.


=== modified file 'lisp/image-mode.el'
--- lisp/image-mode.el  2012-05-03 15:48:02 +0000
+++ lisp/image-mode.el  2012-05-07 23:23:22 +0000
@@ -532,6 +532,7 @@
     (setq image-type type)
     (if (eq major-mode 'image-mode)
        (setq mode-name (format "Image[%s]" type)))
+    (image-transform-check-size)
     (if (called-interactively-p 'any)
        (message "Repeat this command to go back to displaying the file as 
text"))))
 
@@ -636,9 +637,122 @@
  - `fit-width', meaning to fit the image to the window width.
  - A number, which is a scale factor (the default size is 1).")
 
+(defvar image-transform-scale 1.0
+  "The scale factor of the image being displayed.")
+
 (defvar image-transform-rotation 0.0
   "Rotation angle for the image in the current Image mode buffer.")
 
+(defvar image-transform-right-angle-fudge 0.0001
+  "Snap distance to a multiple of a right angle.
+There's no deep theory behind the default value, it should just
+be somewhat larger than ImageMagick's MagickEpsilon.")
+
+(defsubst image-transform-width (width height)
+  "Return the bounding box width of a rotated WIDTH x HEIGHT rectangle.
+The rotation angle is the value of `image-transform-rotation' in degrees."
+  (let ((angle (degrees-to-radians image-transform-rotation)))
+    ;; Assume, w.l.o.g., that the vertices of the rectangle have the
+    ;; coordinates (+-w/2, +-h/2) and that (0, 0) is the center of the
+    ;; rotation by the angle A.  The projections onto the first axis
+    ;; of the vertices of the rotated rectangle are +- (w/2) cos A +-
+    ;; (h/2) sin A, and the difference between the largest and the
+    ;; smallest of the four values is the expression below.
+    (+ (* width (abs (cos angle))) (* height (abs (sin angle))))))
+
+;; The following comment and code snippet are from
+;; ImageMagick-6.7.4-4/magick/distort.c
+
+;;    /* Set the output image geometry to calculated 'bestfit'.
+;;       Yes this tends to 'over do' the file image size, ON PURPOSE!
+;;       Do not do this for DePolar which needs to be exact for virtual tiling.
+;;    */
+;;    if ( fix_bounds ) {
+;;      geometry.x = (ssize_t) floor(min.x-0.5);
+;;      geometry.y = (ssize_t) floor(min.y-0.5);
+;;      geometry.width=(size_t) ceil(max.x-geometry.x+0.5);
+;;      geometry.height=(size_t) ceil(max.y-geometry.y+0.5);
+;;    }
+
+;; Other parts of the same file show that here the origin is in the
+;; left lower corner of the image rectangle, the center of the
+;; rotation is the center of the rectangle and min.x and max.x
+;; (resp. min.y and max.y) are the smallest and the largest of the
+;; projections of the vertices onto the first (resp. second) axis.
+
+(defun image-transform-fit-width (width height length)
+  "Return (w . h) so that a rotated w x h image has exactly width LENGTH.
+The rotation angle is the value of `image-transform-rotation'.
+Write W for WIDTH and H for HEIGHT.  Then the w x h rectangle is
+an \"approximately uniformly\" scaled W x H rectangle, which
+currently means that w is one of floor(s W) + {0, 1, -1} and h is
+floor(s H), where s can be recovered as the value of `image-transform-scale'.
+The value of `image-transform-rotation' may be replaced by
+a slightly different angle.  Currently this is done for values
+close to a multiple of 90, see `image-transform-right-angle-fudge'."
+  (cond ((< (abs (- (mod (+ image-transform-rotation 90) 180) 90))
+           image-transform-right-angle-fudge)
+        (assert (not (zerop width)) t)
+        (setq image-transform-rotation
+              (float (round image-transform-rotation))
+              image-transform-scale (/ (float length) width))
+        (cons length nil))
+       ((< (abs (- (mod (+ image-transform-rotation 45) 90) 45))
+           image-transform-right-angle-fudge)
+        (assert (not (zerop height)) t)
+        (setq image-transform-rotation
+              (float (round image-transform-rotation))
+              image-transform-scale (/ (float length) height))
+        (cons nil length))
+       (t
+        (assert (not (and (zerop width) (zerop height))) t)
+        (setq image-transform-scale
+              (/ (float (1- length)) (image-transform-width width height)))
+        ;; Assume we have a w x h image and an angle A, and let l =
+        ;; l(w, h) = w |cos A| + h |sin A|, which is the actual width
+        ;; of the bounding box of the rotated image, as calculated by
+        ;; `image-transform-width'.  The code snippet quoted above
+        ;; means that ImageMagick puts the rotated image in
+        ;; a bounding box of width L = 2 ceil((w+l+1)/2) - w.
+        ;; Elementary considerations show that this is equivalent to
+        ;; L - w being even and L-3 < l(w, h) <= L-1.  In our case, L is
+        ;; the given `length' parameter and our job is to determine
+        ;; reasonable values for w and h which satisfy these
+        ;; conditions.
+        (let ((w (floor (* image-transform-scale width)))
+              (h (floor (* image-transform-scale height))))
+          ;; Let w and h as bound above.  Then l(w, h) <= l(s W, s H)
+          ;; = L-1 < l(w+1, h+1) = l(w, h) + l(1, 1) <= l(w, h) + 2,
+          ;; hence l(w, h) > (L-1) - 2 = L-3.
+          (cons
+           (cond ((= (mod w 2) (mod length 2))
+                  w)
+                 ;; l(w+1, h) >= l(w, h) > L-3, but does l(w+1, h) <=
+                 ;; L-1 hold?
+                 ((<= (image-transform-width (1+ w) h) (1- length))
+                  (1+ w))
+                 ;; No, it doesn't, but this implies that l(w-1, h) =
+                 ;; l(w+1, h) - l(2, 0) >= l(w+1, h) - 2 > (L-1) -
+                 ;; 2 = L-3.  Clearly, l(w-1, h) <= l(w, h) <= L-1.
+                 (t
+                  (1- w)))
+           h)))))
+
+(defun image-transform-check-size ()
+  "Check that the image exactly fits the width/height of the window."
+  (unless (numberp image-transform-resize)
+    (let ((size (image-display-size (image-get-display-property) t)))
+      (cond ((eq image-transform-resize 'fit-width)
+            (assert (= (car size)
+                       (- (nth 2 (window-inside-pixel-edges))
+                          (nth 0 (window-inside-pixel-edges))))
+                    t))
+           ((eq image-transform-resize 'fit-height)
+            (assert (= (cdr size)
+                       (- (nth 3 (window-inside-pixel-edges))
+                          (nth 1 (window-inside-pixel-edges))))
+                    t))))))
+
 (defun image-transform-properties (spec)
   "Return rescaling/rotation properties for image SPEC.
 These properties are determined by the Image mode variables
@@ -647,27 +761,35 @@
 
 Rescaling and rotation properties only take effect if Emacs is
 compiled with ImageMagick support."
+  (setq image-transform-scale 1.0)
   (when (or image-transform-resize
-           (not (equal image-transform-rotation 0.0)))
+           (/= image-transform-rotation 0.0))
     ;; Note: `image-size' looks up and thus caches the untransformed
     ;; image.  There's no easy way to prevent that.
     (let* ((size (image-size spec t))
-          (height
+          (resized
            (cond
             ((numberp image-transform-resize)
              (unless (= image-transform-resize 1)
-               (floor (* image-transform-resize (cdr size)))))
+               (setq image-transform-scale image-transform-resize)
+               (cons nil (floor (* image-transform-resize (cdr size))))))
+            ((eq image-transform-resize 'fit-width)
+             (image-transform-fit-width
+              (car size) (cdr size)
+              (- (nth 2 (window-inside-pixel-edges))
+                 (nth 0 (window-inside-pixel-edges)))))
             ((eq image-transform-resize 'fit-height)
-             (- (nth 3 (window-inside-pixel-edges))
-                (nth 1 (window-inside-pixel-edges))))))
-          (width (if (eq image-transform-resize 'fit-width)
-                     (- (nth 2 (window-inside-pixel-edges))
-                        (nth 0 (window-inside-pixel-edges))))))
-      ;;TODO fit-to-* should consider the rotation angle
-      `(,@(if height (list :height height))
-       ,@(if width (list :width width))
-       ,@(if (not (equal 0.0 image-transform-rotation))
-             (list :rotation image-transform-rotation))))))
+             (let ((res (image-transform-fit-width
+                         (cdr size) (car size)
+                         (- (nth 3 (window-inside-pixel-edges))
+                            (nth 1 (window-inside-pixel-edges))))))
+               (cons (cdr res) (car res)))))))
+      `(,@(when (car resized)
+           (list :width (car resized)))
+       ,@(when (cdr resized)
+           (list :height (cdr resized)))
+       ,@(unless (= 0.0 image-transform-rotation)
+           (list :rotation image-transform-rotation))))))
 
 (defun image-transform-set-scale (scale)
   "Prompt for a number, and resize the current image by that amount.
@@ -698,9 +820,7 @@
 ROTATION should be in degrees.  This command has no effect unless
 Emacs is compiled with ImageMagick support."
   (interactive "nRotation angle (in degrees): ")
-  ;;TODO 0 90 180 270 degrees are the only reasonable angles here
-  ;;otherwise combining with rescaling will get very awkward
-  (setq image-transform-rotation (float rotation))
+  (setq image-transform-rotation (float (mod rotation 360)))
   (image-toggle-display-image))
 
 (provide 'image-mode)







reply via email to

[Prev in Thread] Current Thread [Next in Thread]