![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 2ad7758a46262720130862ae94502e9f73cb1ae0..08c4d167b2c1672be331110a0df3e0a736618ace 100644 (file)
}
/*
-** Returns the matrix you need to apply to an object with given bbox and strokewidth to
-scale/move it to the new box x0/y0/x1/y1. Takes into account the "scale stroke"
+** Returns the matrix you need to apply to an object with given visual bbox and strokewidth to
+scale/move it to the new visual bbox x0/y0/x1/y1. Takes into account the "scale stroke"
preference value passed to it. Has to solve a quadratic equation to make sure
the goal is met exactly and the stroke scaling is obeyed.
*/
NR::Matrix scale = NR::Matrix (NR::scale (1, 1)); // scale component
NR::Matrix unbudge = NR::Matrix (NR::translate (0, 0)); // move component to compensate for the drift caused by stroke width change
- gdouble w0 = bbox.extent(NR::X);
+ gdouble w0 = bbox.extent(NR::X); // will return a value >= 0, as required further down the road
gdouble h0 = bbox.extent(NR::Y);
- gdouble w1 = x1 - x0;
+ gdouble w1 = x1 - x0; // can have any sign
gdouble h1 = y1 - y0;
gdouble r0 = strokewidth;
@@ -114,43 +114,42 @@ get_scale_transform_with_stroke (NR::Rect &bbox_param, gdouble strokewidth, bool
return (p2o * direct * o2n); // can't solve the equation: one of the dimensions is equal to stroke width, so return the straightforward scaler
}
- // Flip when the width or height changes sign
- int flip_x = ((w1 < 0) == (w0 < 0)) ? 1 : -1;
- int flip_y = ((h1 < 0) == (h0 < 0)) ? 1 : -1;
+ int flip_x = (w1 > 0) ? 1 : -1;
+ int flip_y = (h1 > 0) ? 1 : -1;
- // w1 and h1 can be negative, but if so then e.g. w1-r0 won't make sense
- // therefore we should use fabs() all over the place
- gdouble ratio_x = (fabs(w1) - fabs(r0)) / (fabs(w0) - fabs(r0));
- gdouble ratio_y = (fabs(h1) - fabs(r0)) / (fabs(h0) - fabs(r0));
+ // w1 and h1 will be negative when mirroring, but if so then e.g. w1-r0 won't make sense
+ // 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 extent()
+
+ gdouble ratio_x = (w1 - r0) / (w0 - r0);
+ gdouble ratio_y = (h1 - r0) / (h0 - r0);
- NR::Matrix direct_constant_r = NR::Matrix (NR::scale(flip_x * ratio_x, flip_y*ratio_y));
+ NR::Matrix direct_constant_r = NR::Matrix (NR::scale(flip_x * ratio_x, flip_y * ratio_y));
if (transform_stroke && r0 != 0 && r0 != NR_HUGE) { // there's stroke, and we need to scale it
// These coefficients are obtained from the assumption that scaling applies to the
// non-stroked "shape proper" and that stroke scale is scaled by the expansion of that
- // matrix
- // In fact, we're trying to solve this equation:
- // r1 = r0 * sqrt (((w1-r0)/(w0-r0))*((h1-r1)/(h0-r0)))
- // To make sense of this, the operant of the sqrt() should
- // be positive, hence all the fabs() below
- // (w1 and h1 will be negative when mirroring, w0 and h0 will probably never be negative)
- gdouble A = -fabs(w0*h0) + fabs(r0)*(fabs(w0) + fabs(h0));
- gdouble B = -(fabs(w1) + fabs(h1)) * r0*r0;
- gdouble C = fabs(w1 * h1 * r0*r0);
+ // matrix. We're trying to solve this equation:
+ // r1 = r0 * sqrt (((w1-r0)/(w0-r0))*((h1-r0)/(h0-r0)))
+ // The operant of the sqrt() must be positive, which is ensured by the fabs() a few lines above
+ 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) {
- gdouble r1 = (-B - sqrt (B*B - 4*A*C))/(2*A);
+ gdouble r1 = fabs((-B - sqrt(B*B - 4*A*C))/(2*A));
//gdouble r2 = (-B + sqrt (B*B - 4*A*C))/(2*A);
//std::cout << "r0" << r0 << " r1" << r1 << " r2" << r2 << "\n";
//
- // I think r1 will always be positive if r0 is (mathematical proof?)
- // but if w1 becomes negative, then the scale will be wrong if we just do
+ // If w1 < 0 then the scale will be wrong if we just do
// gdouble scale_x = (w1 - r1)/(w0 - r0);
- // gdouble scale_y = (h1 - r1)/(h0 - r0);
- // So let's do it like this: Calculate the absolute scale
- gdouble scale_x = (fabs(w1) - fabs(r1))/(fabs(w0) - fabs(r0));
- gdouble scale_y = (fabs(h1) - fabs(r1))/(fabs(h0) - fabs(r0));
- scale *= NR::scale(flip_x*scale_x, flip_y*scale_y);
- unbudge *= NR::translate (-flip_x * 0.5 * (fabs(r0) * scale_x - fabs(r1)), -flip_y * 0.5 * (fabs(r0) * scale_y - fabs(r1)));
+ // Here we also need the absolute values of w0, w1, h0, h1, and r1
+ gdouble scale_x = (w1 - r1)/(w0 - r0);
+ gdouble scale_y = (h1 - r1)/(h0 - r0);
+ scale *= NR::scale(flip_x * scale_x, flip_y * scale_y);
+ unbudge *= NR::translate (-flip_x * 0.5 * (r0 * scale_x - r1), -flip_y * 0.5 * (r0 * scale_y - r1));
} else {
scale *= direct;
}
@@ -159,13 +158,45 @@ get_scale_transform_with_stroke (NR::Rect &bbox_param, gdouble strokewidth, bool
scale *= direct;
} else {// nonscaling strokewidth
scale *= direct_constant_r;
- unbudge *= NR::translate (flip_x * 0.5 * fabs(r0) * (1 - ratio_x), flip_y * 0.5 * fabs(r0) * (1 - ratio_y));
+ unbudge *= NR::translate (flip_x * 0.5 * r0 * (1 - ratio_x), flip_y * 0.5 * r0 * (1 - ratio_y));
}
}
return (p2o * scale * unbudge * o2n);
}
+NR::Rect
+get_visual_bbox (NR::Maybe<NR::Rect> const &initial_geom_bbox, NR::Matrix const &abs_affine, gdouble const initial_strokewidth, bool const transform_stroke)
+{
+
+ g_assert(initial_geom_bbox);
+
+ // Find the new geometric bounding box; Do this by transforming each corner of
+ // the initial geometric bounding box individually and fitting a new boundingbox
+ // around the transformerd corners
+ NR::Point const p0 = initial_geom_bbox->corner(0) * abs_affine;
+ NR::Rect new_geom_bbox = NR::Rect(p0, p0);
+ for (unsigned i = 1 ; i < 4 ; i++) {
+ new_geom_bbox.expandTo(initial_geom_bbox->corner(i) * abs_affine);
+ }
+
+ NR::Rect new_visual_bbox = new_geom_bbox;
+ if (initial_strokewidth > 0 && initial_strokewidth < NR_HUGE) {
+ if (transform_stroke) {
+ // scale stroke by: sqrt (((w1-r0)/(w0-r0))*((h1-r0)/(h0-r0))) (for visual bboxes, see get_scale_transform_with_stroke)
+ // equals scaling by: sqrt ((w1/w0)*(h1/h0)) for geometrical bboxes
+ // equals scaling by: sqrt (area1/area0) for geometrical bboxes
+ gdouble const new_strokewidth = initial_strokewidth * sqrt (new_geom_bbox.area() / initial_geom_bbox->area());
+ new_visual_bbox.growBy(0.5 * new_strokewidth);
+ } else {
+ // Do not transform the stroke
+ new_visual_bbox.growBy(0.5 * initial_strokewidth);
+ }
+ }
+
+ return new_visual_bbox;
+}
+
/*
Local Variables:
mode:c++