Commit a merge to trunk, with probabal errors

(bzr r11073.1.36)

1 files changed, 158 insertions, 146 deletions

diff --git a/src/sp-item-transform.cpp b/src/sp-item-transform.cpp
index a8d553e9f..086da56ff 100644
--- a/src/sp-item-transform.cpp
+++ b/src/sp-item-transform.cpp
@@ -16,6 +16,7 @@
 
 #include <2geom/transforms.h>
 #include "sp-item.h"
+#include "sp-item-transform.h"
 
 void sp_item_rotate_rel(SPItem *item, Geom::Rotate const &rotation)
 {
@@ -83,8 +84,10 @@ void sp_item_move_rel(SPItem *item, Geom::Translate const &tr)
  * the strokewidth, which is either constant or scales width the area of the object. This function takes care of the calculation
  * of the affine transformation:
  * @param bbox_visual Current visual bounding box
- * @param strokewidth Strokewidth
+ * @param stroke_x Apparent strokewidth in horizontal direction
+ * @param stroke_y Apparent strokewidth in vertical direction
  * @param transform_stroke If true then the stroke will be scaled proportional to the square root of the area of the geometric bounding box
+ * @param preserve If true then the transform element will be preserved in XML, and evaluated after stroke is applied
  * @param x0 Coordinate of the target visual bounding box
  * @param y0 Coordinate of the target visual bounding box
  * @param x1 Coordinate of the target visual bounding box
@@ -93,7 +96,7 @@ void sp_item_move_rel(SPItem *item, Geom::Translate const &tr)
  *   not possible here because it will only allow for a positive width and height, and therefore cannot mirror
  * @return
  */
-Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visual, gdouble strokewidth, bool transform_stroke, gdouble x0, gdouble y0, gdouble x1, gdouble y1)
+Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visual, gdouble stroke_x, gdouble stroke_y, bool transform_stroke, bool preserve, gdouble x0, gdouble y0, gdouble x1, gdouble y1)
 {
     Geom::Affine p2o = Geom::Translate (-bbox_visual.min());
     Geom::Affine o2n = Geom::Translate (x0, y0);
@@ -102,13 +105,16 @@ Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visua
     Geom::Affine unbudge = Geom::Translate (0, 0); // moves the object(s) to compensate for the drift caused by stroke width change
 
     // 1) We start with a visual bounding box (w0, h0) which we want to transfer into another visual bounding box (w1, h1)
-    // 2) The stroke is r0, equal for all edges
+    // 2) The stroke is r0, equal for all edges, if preserve transforms is false
     // 3) Given this visual bounding box we can calculate the geometric bounding box by subtracting half the stroke from each side;
     // -> The width and height of the geometric bounding box will therefore be (w0 - 2*0.5*r0) and (h0 - 2*0.5*r0)
+    // 4) If preserve transforms is true, then stroke_x != stroke_y, since these are the apparent stroke widths, after transforming
+
+    if ((stroke_x == Geom::infinity()) || (fabs(stroke_x) < 1e-6)) stroke_x = 0;
+    if ((stroke_y == Geom::infinity()) || (fabs(stroke_y) < 1e-6)) stroke_y = 0;
 
     gdouble w0 = bbox_visual.width(); // will return a value >= 0, as required further down the road
     gdouble h0 = bbox_visual.height();
-    gdouble r0 = fabs(strokewidth);
 
     // We also know the width and height of the new visual bounding box
     gdouble w1 = x1 - x0; // can have any sign
@@ -123,81 +129,94 @@ Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visua
     // Therefore we will use the absolute values from this point on
     w1 = fabs(w1);
     h1 = fabs(h1);
-    r0 = fabs(r0);
     // w0 and h0 will always be positive due to the definition of the width() and height() methods.
 
+    // Check whether the stroke is negative; i.e. the geometric bounding box is larger than the visual bounding box, which
+    // occurs for example for clipped objects (see launchpad bug #811819)
+    if (stroke_x < 0 || stroke_y < 0) {
+        Geom::Affine direct = Geom::Scale(flip_x * w1 / w0, flip_y* h1 / h0); // Scaling of the visual bounding box
+        // How should we handle the stroke width scaling of clipped object? I don't know if we can/should handle this,
+        // so for now we simply return the direct scaling
+        return (p2o * direct * o2n);
+    }
+    gdouble r0 = sqrt(stroke_x*stroke_y); // r0 is redundant, used only for those cases where stroke_x = stroke_y
+
     // We will now try to calculate the affine transformation required to transform the first visual bounding box into
     // the second one, while accounting for strokewidth
 
-    if ((fabs(w0 - r0) < 1e-6) && (fabs(h0 - r0) < 1e-6)) {
+    if ((fabs(w0 - stroke_x) < 1e-6) && (fabs(h0 - stroke_y) < 1e-6)) {
         return Geom::Affine();
     }
 
-    Geom::Affine direct;
-    gdouble ratio_x = 1;
-    gdouble ratio_y = 1;
     gdouble scale_x = 1;
     gdouble scale_y = 1;
     gdouble r1 = r0;
 
-    if (fabs(w0 - r0) < 1e-6) { // We have a vertical line at hand
-        direct = Geom::Scale(flip_x, flip_y * h1 / h0);
-        ratio_x = 1;
-        ratio_y = (h1 - r0) / (h0 - r0);
-        r1 = transform_stroke ? r0 * sqrt(h1/h0) : r0;
-        scale_x = 1;
-        scale_y = (h1 - r1)/(h0 - r0);
-    } else if (fabs(h0 - r0) < 1e-6) { // We have a horizontal line at hand
-        direct = Geom::Scale(flip_x * w1 / w0, flip_y);
-        ratio_x = (w1 - r0) / (w0 - r0);
-        ratio_y = 1;
-        r1 = transform_stroke ? r0 * sqrt(w1/w0) : r0;
-        scale_x = (w1 - r1)/(w0 - r0);
-        scale_y = 1;
+    if ((fabs(w0 - stroke_x) < 1e-6) || w1 == 0) { // We have a vertical line at hand
+        scale_y = h1/h0;
+        scale_x = transform_stroke ? 1 : scale_y;
+        unbudge *= Geom::Translate (-flip_x * 0.5 * (scale_x - 1.0) * w0, 0);
+        unbudge *= Geom::Translate ( flip_x * 0.5 * (w1 - w0), 0); // compensate for the fact that this operation cannot be performed
+    } else if ((fabs(h0 - stroke_y) < 1e-6) || h1 == 0) { // We have a horizontal line at hand
+        scale_x = w1/w0;
+        scale_y = transform_stroke ? 1 : scale_x;
+        unbudge *= Geom::Translate (0, -flip_y * 0.5 * (scale_y - 1.0) * h0);
+        unbudge *= Geom::Translate (0,  flip_y * 0.5 * (h1 - h0)); // compensate for the fact that this operation cannot be performed
     } else { // We have a true 2D object at hand
-        direct = Geom::Scale(flip_x * w1 / w0, flip_y* h1 / h0); // Scaling of the visual bounding box
-        ratio_x = (w1 - r0) / (w0 - r0); // Only valid when the stroke is kept constant, in which case r1 = r0
-        ratio_y = (h1 - r0) / (h0 - r0);
-        /* Initial area of the geometric bounding box: A0 = (w0-r0)*(h0-r0)
-         * Desired area of the geometric bounding box: A1 = (w1-r1)*(h1-r1)
-         * This is how the stroke should scale: r1^2 / A1 = r0^2 / A0
-         * So therefore we will need to solve this equation:
-         *
-         * r1^2 * (w0-r0) * (h1-r1) = r0^2 * (w1-r1) * (h0-r0)
-         *
-         * This is a quadratic equation in r1, of which the roots can be found using the ABC formula
-         * */
-        gdouble A = -w0*h0 + r0*(w0 + h0);
-        gdouble B = -(w1 + h1) * r0*r0;
-        gdouble C = w1 * h1 * r0*r0;
-        if (B*B - 4*A*C > 0) {
-            // Of the two roots, I verified experimentally that this is the one we need
-            r1 = fabs((-B - sqrt(B*B - 4*A*C))/(2*A));
-            // If w1 < 0 then the scale will be wrong if we just assume that scale_x = (w1 - r1)/(w0 - r0);
-            // Therefore we here need the absolute values of w0, w1, h0, h1, and r0, as taken care of earlier
-            scale_x = (w1 - r1)/(w0 - r0);
-            scale_y = (h1 - r1)/(h0 - r0);
-        } else { // Can't find the roots of the quadratic equation. Likely the input parameters are invalid?
-            r1 = r0;
+        if (transform_stroke && !preserve) {
+            /* Initial area of the geometric bounding box: A0 = (w0-r0)*(h0-r0)
+             * Desired area of the geometric bounding box: A1 = (w1-r1)*(h1-r1)
+             * This is how the stroke should scale: r1^2 / A1 = r0^2 / A0
+             * So therefore we will need to solve this equation:
+             *
+             * r1^2 * (w0-r0) * (h0-r0) = r0^2 * (w1-r1) * (h1-r1)
+             *
+             * This is a quadratic equation in r1, of which the roots can be found using the ABC formula
+             * */
+            gdouble A = -w0*h0 + r0*(w0 + h0);
+            gdouble B = -(w1 + h1) * r0*r0;
+            gdouble C = w1 * h1 * r0*r0;
+            if (B*B - 4*A*C < 0) {
+                g_message("stroke scaling error : %d, %f, %f, %f, %f, %f", preserve, r0, w0, h0, w1, h1);
+            } else {
+                r1 = fabs((-B - sqrt(B*B - 4*A*C))/(2*A));
+                // If w1 < 0 then the scale will be wrong if we just assume that scale_x = (w1 - r1)/(w0 - r0);
+                // Therefore we here need the absolute values of w0, w1, h0, h1, and r0, as taken care of earlier
+                scale_x = (w1 - r1)/(w0 - r0);
+                scale_y = (h1 - r1)/(h0 - r0);
+                // Make sure that the lower-left corner of the visual bounding box stays where it is, even though the stroke width has changed
+                unbudge *= Geom::Translate (-flip_x * 0.5 * (r0 * scale_x - r1), -flip_y * 0.5 * (r0 * scale_y - r1));
+            }
+        } else if (!transform_stroke && !preserve) { // scale the geometric bbox with constant stroke
+            scale_x = (w1 - r0) / (w0 - r0);
+            scale_y = (h1 - r0) / (h0 - r0);
+            unbudge *= Geom::Translate (-flip_x * 0.5 * r0 * (scale_x - 1), -flip_y * 0.5 * r0 * (scale_y - 1));
+        } else if (!transform_stroke) { // 'Preserve Transforms' was chosen.
+            // geometric mean of stroke_x and stroke_y will be preserved
+            // new_stroke_x = stroke_x*sqrt(scale_x/scale_y)
+            // new_stroke_y = stroke_y*sqrt(scale_y/scale_x)
+            // scale_x = (w1 - new_stroke_x)/(w0 - stroke_x)
+            // scale_y = (h1 - new_stroke_y)/(h0 - stroke_y)
+            gdouble A = h1*(w0 - stroke_x);
+            gdouble B = (h0*stroke_x - w0*stroke_y);
+            gdouble C = -w1*(h0 - stroke_y);
+            gdouble Sx_div_Sy;          // Sx_div_Sy = sqrt(scale_x/scale_y)
+            if (B*B - 4*A*C < 0) {
+                g_message("stroke scaling error : %d, %f, %f, %f, %f, %f, %f", preserve, stroke_x, stroke_y, w0, h0, w1, h1);
+            } else {
+                Sx_div_Sy = (-B + sqrt(B*B - 4*A*C))/2/A;
+                scale_x = (w1 - stroke_x*Sx_div_Sy)/(w0 - stroke_x);
+                scale_y = (h1 - stroke_y/Sx_div_Sy)/(h0 - stroke_y);
+                unbudge *= Geom::Translate (-flip_x * 0.5 * stroke_x * scale_x * (1.0 - sqrt(1.0/scale_x/scale_y)), -flip_y * 0.5 * stroke_y * scale_y * (1.0 - sqrt(1.0/scale_x/scale_y)));
+            }
+        } else {                        // 'Preserve Transforms' was chosen, and stroke is scaled
             scale_x = w1 / w0;
             scale_y = h1 / h0;
         }
     }
 
-    // If the stroke is not kept constant however, the scaling of the geometric bbox is more difficult to find
-    if (transform_stroke && r0 != 0 && r0 != Geom::infinity()) { // Check if there's stroke, and we need to scale it
-        // Now we account for mirroring by flipping if needed
-        scale *= Geom::Scale(flip_x * scale_x, flip_y * scale_y);
-        // Make sure that the lower-left corner of the visual bounding box stays where it is, even though the stroke width has changed
-        unbudge *= Geom::Translate (-flip_x * 0.5 * (r0 * scale_x - r1), -flip_y * 0.5 * (r0 * scale_y - r1));
-    } else { // The stroke should not be scaled, or is zero
-        if (r0 == 0 || r0 == Geom::infinity() ) { // Strokewidth is zero or infinite
-            scale *= direct;
-        } else { // Nonscaling strokewidth
-            scale *= Geom::Scale(flip_x * ratio_x, flip_y * ratio_y); // Scaling of the geometric bounding box for constant stroke width
-            unbudge *= Geom::Translate (flip_x * 0.5 * r0 * (1 - ratio_x), flip_y * 0.5 * r0 * (1 - ratio_y));
-        }
-    }
+    // Now we account for mirroring by flipping if needed
+    scale *= Geom::Scale(flip_x * scale_x, flip_y * scale_y);
 
     return (p2o * scale * unbudge * o2n);
 }
@@ -221,6 +240,7 @@ Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visua
  * @param bbox_visual Current visual bounding box
  * @param bbox_geometric Current geometric bounding box (allows for calculating the strokewidth of each edge)
  * @param transform_stroke If true then the stroke will be scaled proportional to the square root of the area of the geometric bounding box
+ * @param preserve If true then the transform element will be preserved in XML, and evaluated after stroke is applied
  * @param x0 Coordinate of the target visual bounding box
  * @param y0 Coordinate of the target visual bounding box
  * @param x1 Coordinate of the target visual bounding box
@@ -229,7 +249,7 @@ Geom::Affine get_scale_transform_for_uniform_stroke(Geom::Rect const &bbox_visua
  *    not possible here because it will only allow for a positive width and height, and therefore cannot mirror
  * @return
  */
-Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visual, Geom::Rect const &bbox_geom, bool transform_stroke, gdouble x0, gdouble y0, gdouble x1, gdouble y1)
+Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visual, Geom::Rect const &bbox_geom, bool transform_stroke, bool preserve, gdouble x0, gdouble y0, gdouble x1, gdouble y1)
 {
     Geom::Affine p2o = Geom::Translate (-bbox_visual.min());
     Geom::Affine o2n = Geom::Translate (x0, y0);
@@ -239,7 +259,7 @@ Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visu
 
     // 1) We start with a visual bounding box (w0, h0) which we want to transfer into another visual bounding box (w1, h1)
     // 2) We will also know the geometric bounding box, which can be used to calculate the strokewidth. The strokewidth will however
-    //      be different for each of the four sides (left/right/top/bottom: r0l, r0r, r0t, r0b)
+    //    be different for each of the four sides (left/right/top/bottom: r0l, r0r, r0t, r0b)
 
     gdouble w0 = bbox_visual.width(); // will return a value >= 0, as required further down the road
     gdouble h0 = bbox_visual.height();
@@ -251,8 +271,10 @@ Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visu
 
     // We will now try to calculate the affine transformation required to transform the first visual bounding box into
     // the second one, while accounting for strokewidth
-    gdouble r0w = w0 - bbox_geom.width(); // r0w is the average strokewidth of the left and right edges, i.e. 0.5*(r0l + r0r)
+    gdouble r0w = w0 - bbox_geom.width();  // r0w is the average strokewidth of the left and right edges, i.e. 0.5*(r0l + r0r)
     gdouble r0h = h0 - bbox_geom.height(); // r0h is the average strokewidth of the top and bottom edges, i.e. 0.5*(r0t + r0b)
+    if ((r0w == Geom::infinity()) || (fabs(r0w) < 1e-6)) r0w = 0;
+    if ((r0h == Geom::infinity()) || (fabs(r0h) < 1e-6)) r0h = 0;
 
     int flip_x = (w1 > 0) ? 1 : -1;
     int flip_y = (h1 > 0) ? 1 : -1;
@@ -267,79 +289,10 @@ Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visu
         return Geom::Affine();
     }
 
-    Geom::Affine direct;
-    gdouble ratio_x = 1;
-    gdouble ratio_y = 1;
-    gdouble scale_x = 1;
-    gdouble scale_y = 1;
-    gdouble r1h = r0h;
-    gdouble r1w = r0w;
-
-    if (fabs(w0 - r0w) < 1e-6) { // We have a vertical line at hand
-        direct = Geom::Scale(flip_x, flip_y * h1 / h0);
-        ratio_x = 1;
-        ratio_y = (h1 - r0h) / (h0 - r0h);
-        r1h = transform_stroke ? r0h * sqrt(h1/h0) : r0h;
-        scale_x = 1;
-        scale_y = (h1 - r1h)/(h0 - r0h);
-    } else if (fabs(h0 - r0h) < 1e-6) { // We have a horizontal line at hand
-        direct = Geom::Scale(flip_x * w1 / w0, flip_y);
-        ratio_x = (w1 - r0w) / (w0 - r0w);
-        ratio_y = 1;
-        r1w = transform_stroke ? r0w * sqrt(w1/w0) : r0w;
-        scale_x = (w1 - r1w)/(w0 - r0w);
-        scale_y = 1;
-    } else { // We have a true 2D object at hand
-        direct = Geom::Scale(flip_x * w1 / w0, flip_y* h1 / h0); // Scaling of the visual bounding box
-        ratio_x = (w1 - r0w) / (w0 - r0w); // Only valid when the stroke is kept constant, in which case r1 = r0
-        ratio_y = (h1 - r0h) / (h0 - r0h);
-        /* Initial area of the geometric bounding box: A0 = (w0-r0w)*(h0-r0h)
-         * Desired area of the geometric bounding box: A1 = (w1-r1w)*(h1-r1h)
-         * This is how the stroke should scale:     r1w^2 = A1/A0 * r0w^2, AND
-         *                                          r1h^2 = A1/A0 * r0h^2
-         * Now we have to solve this set of two equations and find r1w and r1h; this too complicated to do by hand,
-         * so I used wxMaxima for that (http://wxmaxima.sourceforge.net/). These lines can be copied into Maxima
-         *
-         * A1: (w1-r1w)*(h1-r1h);
-         * s: A1/A0;
-         * expr1a: r1w^2 = s*r0w^2;
-         * expr1b: r1h^2 = s*r0h^2;
-         * sol: solve([expr1a, expr1b], [r1h, r1w]);
-         * sol[1][1]; sol[2][1]; sol[3][1]; sol[4][1];
-         * sol[1][2]; sol[2][2]; sol[3][2]; sol[4][2];
-         *
-         * PS1: The last two lines are only needed for readability of the output, and can be omitted if desired
-         * PS2: A0 is known beforehand and assumed to be constant, instead of using A0 = (w0-r0w)*(h0-r0h). This reduces the
-         * length of the results significantly
-         * PS3: You'll get 8 solutions, 4 for each of the strokewidths r1w and r1h. Some experiments quickly showed which of the solutions
-         * lead to meaningful strokewidths
-         * */
-        gdouble r0h2 = r0h*r0h;
-        gdouble r0h3 = r0h2*r0h;
-        gdouble r0w2 = r0w*r0w;
-        gdouble w12 = w1*w1;
-        gdouble h12 = h1*h1;
-        gdouble A0 = bbox_geom.area();
-        gdouble A02 = A0*A0;
-
-        gdouble operant = 4*h1*w1*A0+r0h2*w12-2*h1*r0h*r0w*w1+h12*r0w2;
-        if (operant >= 0) {
-            // Of the eight roots, I verified experimentally that these are the two we need
-            r1h = fabs((r0h*sqrt(operant)-r0h2*w1-h1*r0h*r0w)/(2*A0-2*r0h*r0w));
-            r1w = fabs(-((h1*r0w*A0+r0h2*r0w*w1)*sqrt(operant)+(-3*h1*r0h*r0w*w1-h12*r0w2)*A0-r0h3*r0w*w12+h1*r0h2*r0w2*w1)/((r0h*A0-r0h2*r0w)*sqrt(operant)-2*h1*A02+(3*h1*r0h*r0w-r0h2*w1)*A0+r0h3*r0w*w1-h1*r0h2*r0w2));
-            // If w1 < 0 then the scale will be wrong if we just assume that scale_x = (w1 - r1)/(w0 - r0);
-            // Therefore we here need the absolute values of w0, w1, h0, h1, and r0, as taken care of earlier
-            scale_x = (w1 - r1w)/(w0 - r0w);
-            scale_y = (h1 - r1h)/(h0 - r0h);
-        } else { // Can't find the roots of the quadratic equation. Likely the input parameters are invalid?
-            scale_x = w1 / w0;
-            scale_y = h1 / h0;
-        }
-    }
-
     // Check whether the stroke is negative; i.e. the geometric bounding box is larger than the visual bounding box, which
     // occurs for example for clipped objects (see launchpad bug #811819)
     if (r0w < 0 || r0h < 0) {
+        Geom::Affine direct = Geom::Scale(flip_x * w1 / w0, flip_y* h1 / h0); // Scaling of the visual bounding box
         // How should we handle the stroke width scaling of clipped object? I don't know if we can/should handle this,
         // so for now we simply return the direct scaling
         return (p2o * direct * o2n);
@@ -351,21 +304,80 @@ Geom::Affine get_scale_transform_for_variable_stroke(Geom::Rect const &bbox_visu
     gdouble stroke_ratio_w = fabs(r0w) < 1e-6 ? 1 : (bbox_geom[Geom::X].min() - bbox_visual[Geom::X].min())/r0w;
     gdouble stroke_ratio_h = fabs(r0h) < 1e-6 ? 1 : (bbox_geom[Geom::Y].min() - bbox_visual[Geom::Y].min())/r0h;
 
-    // If the stroke is not kept constant however, the scaling of the geometric bbox is more difficult to find
-    if (transform_stroke && r0w != 0 && r0w != Geom::infinity() && r0h != 0 && r0h != Geom::infinity()) {  // Check if there's stroke, and we need to scale it
-        // Now we account for mirroring by flipping if needed
-        scale *= Geom::Scale(flip_x * scale_x, flip_y * scale_y);
-        // Make sure that the lower-left corner of the visual bounding box stays where it is, even though the stroke width has changed
-        unbudge *= Geom::Translate (-flip_x * stroke_ratio_w * (r0w * scale_x - r1w), -flip_y * stroke_ratio_h * (r0h * scale_y - r1h));
-    } else { // The stroke should not be scaled, or is zero (or infinite)
-        if (r0w == 0 || r0w == Geom::infinity() || r0h == 0 || r0h == Geom::infinity()) { // can't calculate, because apparently strokewidth is zero or infinite
-            scale *= direct;
-        } else {
-            scale *= Geom::Scale(flip_x * ratio_x, flip_y * ratio_y); // Scaling of the geometric bounding box for constant stroke width
-            unbudge *= Geom::Translate (flip_x * stroke_ratio_w * r0w * (1 - ratio_x), flip_y * stroke_ratio_h * r0h * (1 - ratio_y));
+    gdouble scale_x = 1;
+    gdouble scale_y = 1;
+    gdouble r1h = r0h;
+    gdouble r1w = r0w;
+
+    if ((fabs(w0 - r0w) < 1e-6) || w1 == 0) { // We have a vertical line at hand
+        scale_y = h1/h0;
+        scale_x = transform_stroke ? 1 : scale_y;
+        unbudge *= Geom::Translate (-flip_x * 0.5 * (scale_x - 1.0) * w0, 0);
+        unbudge *= Geom::Translate ( flip_x * 0.5 * (w1 - w0), 0); // compensate for the fact that this operation cannot be performed
+    } else if ((fabs(h0 - r0h) < 1e-6) || h1 == 0) { // We have a horizontal line at hand
+        scale_x = w1/w0;
+        scale_y = transform_stroke ? 1 : scale_x;
+        unbudge *= Geom::Translate (0, -flip_y * 0.5 * (scale_y - 1.0) * h0);
+        unbudge *= Geom::Translate (0,  flip_y * 0.5 * (h1 - h0)); // compensate for the fact that this operation cannot be performed
+    } else { // We have a true 2D object at hand
+        if (transform_stroke && !preserve) {
+            /* Initial area of the geometric bounding box: A0 = (w0-r0w)*(h0-r0h)
+             * Desired area of the geometric bounding box: A1 = (w1-r1w)*(h1-r1h)
+             * This is how the stroke should scale:     r1w^2 = A1/A0 * r0w^2, AND
+             *                                          r1h^2 = A1/A0 * r0h^2
+             * These can be re-expressed as : r1w/r0w = r1h/r0h
+             * and : r1w*r1w*(w0 - r0w)*(h0 - r0h) = r0w*r0w*(w1 - r1w)*(h1 - r1h)
+             * This leads to a quadratic equation in r1w, solved as follows:
+             * */
+
+            gdouble A = w0*h0 - r0h*w0 - r0w*h0;
+            gdouble B = r0h*w1 + r0w*h1;
+            gdouble C = -w1*h1;
+
+            if (B*B - 4*A*C < 0) {
+                g_message("variable stroke scaling error : %d, %d, %f, %f, %f, %f, %f, %f", transform_stroke, preserve, r0w, r0h, w0, h0, w1, h1);
+            } else {
+                gdouble det = (-B + sqrt(B*B - 4*A*C))/(2*A);
+                r1w = r0w*det;
+                r1h = r0h*det;
+                // If w1 < 0 then the scale will be wrong if we just assume that scale_x = (w1 - r1)/(w0 - r0);
+                // Therefore we here need the absolute values of w0, w1, h0, h1, and r0, as taken care of earlier
+                scale_x = (w1 - r1w)/(w0 - r0w);
+                scale_y = (h1 - r1h)/(h0 - r0h);
+                // Make sure that the lower-left corner of the visual bounding box stays where it is, even though the stroke width has changed
+                unbudge *= Geom::Translate (-flip_x * stroke_ratio_w * (r0w * scale_x - r1w), -flip_y * stroke_ratio_h * (r0h * scale_y - r1h));
+            }
+        } else if (!transform_stroke && !preserve) { // scale the geometric bbox with constant stroke
+            scale_x = (w1 - r0w) / (w0 - r0w);
+            scale_y = (h1 - r0h) / (h0 - r0h);
+            unbudge *= Geom::Translate (-flip_x * stroke_ratio_w * r0w * (scale_x - 1), -flip_y * stroke_ratio_h * r0h * (scale_y - 1));
+        } else if (!transform_stroke) { // 'Preserve Transforms' was chosen.
+            // geometric mean of r0w and r0h will be preserved
+            // new_r0w = r0w*sqrt(scale_x/scale_y)
+            // new_r0h = r0h*sqrt(scale_y/scale_x)
+            // scale_x = (w1 - new_r0w)/(w0 - r0w)
+            // scale_y = (h1 - new_r0h)/(h0 - r0h)
+            gdouble A = h1*(w0 - r0w);
+            gdouble B = (h0*r0w - w0*r0h);
+            gdouble C = -w1*(h0 - r0h);
+            gdouble Sx_div_Sy;          // Sx_div_Sy = sqrt(scale_x/scale_y)
+            if (B*B - 4*A*C < 0) {
+                g_message("variable stroke scaling error : %d, %d, %f, %f, %f, %f, %f, %f", transform_stroke, preserve, r0w, r0h, w0, h0, w1, h1);
+            } else {
+                Sx_div_Sy = (-B + sqrt(B*B - 4*A*C))/2/A;
+                scale_x = (w1 - r0w*Sx_div_Sy)/(w0 - r0w);
+                scale_y = (h1 - r0h/Sx_div_Sy)/(h0 - r0h);
+                unbudge *= Geom::Translate (-flip_x * stroke_ratio_w * r0w * scale_x * (1.0 - sqrt(1.0/scale_x/scale_y)), -flip_y * stroke_ratio_h * r0h * scale_y * (1.0 - sqrt(1.0/scale_x/scale_y)));
+            }
+        } else {                        // 'Preserve Transforms' was chosen, and stroke is scaled
+            scale_x = w1 / w0;
+            scale_y = h1 / h0;
         }
     }
 
+    // Now we account for mirroring by flipping if needed
+    scale *= Geom::Scale(flip_x * scale_x, flip_y * scale_y);
+
     return (p2o * scale * unbudge * o2n);
 }