src/sp-item-transform.cpp

   1 #define __SP_ITEM_TRANSFORM_C__
   2
   3 /*
   4  * Transforming single items
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   Frank Felfe <innerspace@iname.com>
   9  *   bulia byak <buliabyak@gmail.com>
  10  *   Johan Engelen <goejendaagh@zonnet.nl>
  11  *
  12  * Copyright (C) 1999-2008 authors
  13  *
  14  * Released under GNU GPL, read the file 'COPYING' for more information
  15  */
  16
  17 #include <2geom/transforms.h>
  18 #include "sp-item.h"
  19
  20 void
  21 sp_item_rotate_rel(SPItem *item, Geom::Rotate const &rotation)
  22 {
  23     Geom::Point center = item->getCenter();
  24     Geom::Translate const s(item->getCenter());
  25     Geom::Matrix affine = Geom::Matrix(s).inverse() * Geom::Matrix(rotation) * Geom::Matrix(s);
  26
  27     // Rotate item.
  28     sp_item_set_i2d_affine(item, sp_item_i2d_affine(item) * (Geom::Matrix)affine);
  29     // Use each item's own transform writer, consistent with sp_selection_apply_affine()
  30     sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform);
  31
  32     // Restore the center position (it's changed because the bbox center changed)
  33     if (item->isCenterSet()) {
  34         item->setCenter(center * affine);
  35     }
  36 }
  37
  38 void
  39 sp_item_scale_rel (SPItem *item, Geom::Scale const &scale)
  40 {
  41     Geom::OptRect bbox = sp_item_bbox_desktop(item);
  42     if (bbox) {
  43         Geom::Translate const s(bbox->midpoint()); // use getCenter?
  44         sp_item_set_i2d_affine(item, sp_item_i2d_affine(item) * s.inverse() * scale * s);
  45         sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform);
  46     }
  47 }
  48
  49 void
  50 sp_item_skew_rel (SPItem *item, double skewX, double skewY)
  51 {
  52     Geom::Point center = item->getCenter();
  53     Geom::Translate const s(item->getCenter());
  54
  55     Geom::Matrix const skew(1, skewY, skewX, 1, 0, 0);
  56     Geom::Matrix affine = Geom::Matrix(s).inverse() * skew * Geom::Matrix(s);
  57
  58     sp_item_set_i2d_affine(item, sp_item_i2d_affine(item) * affine);
  59     sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform);
  60
  61     // Restore the center position (it's changed because the bbox center changed)
  62     if (item->isCenterSet()) {
  63         item->setCenter(center * affine);
  64     }
  65 }
  66
  67 void sp_item_move_rel(SPItem *item, Geom::Translate const &tr)
  68 {
  69         sp_item_set_i2d_affine(item, sp_item_i2d_affine(item) * tr);
  70
  71         sp_item_write_transform(item, SP_OBJECT_REPR(item), item->transform);
  72 }
  73
  74 /*
  75 ** Returns the matrix you need to apply to an object with given visual bbox and strokewidth to
  76 scale/move it to the new visual bbox x0/y0/x1/y1. Takes into account the "scale stroke"
  77 preference value passed to it. Has to solve a quadratic equation to make sure
  78 the goal is met exactly and the stroke scaling is obeyed.
  79 */
  80
  81 Geom::Matrix
  82 get_scale_transform_with_stroke (Geom::Rect const &bbox_param, gdouble strokewidth, bool transform_stroke, gdouble x0, gdouble y0, gdouble x1, gdouble y1)
  83 {
  84     Geom::Rect bbox (bbox_param);
  85
  86     Geom::Matrix p2o = Geom::Translate (-bbox.min());
  87     Geom::Matrix o2n = Geom::Translate (x0, y0);
  88
  89     Geom::Matrix scale = Geom::Scale (1, 1); // scale component
  90     Geom::Matrix unbudge = Geom::Translate (0, 0); // move component to compensate for the drift caused by stroke width change
  91
  92     gdouble w0 = bbox[Geom::X].extent(); // will return a value >= 0, as required further down the road
  93     gdouble h0 = bbox[Geom::Y].extent();
  94     gdouble w1 = x1 - x0; // can have any sign
  95     gdouble h1 = y1 - y0;
  96     gdouble r0 = strokewidth;
  97
  98     if (bbox.hasZeroArea()) {
  99         Geom::Matrix move = Geom::Translate(x0 - bbox.min()[Geom::X], y0 - bbox.min()[Geom::Y]);
 100         return (move); // cannot scale from empty boxes at all, so only translate
 101     }
 102
 103     Geom::Matrix direct = Geom::Scale(w1 / w0,   h1 / h0);
 104
 105     if (fabs(w0 - r0) < 1e-6 || fabs(h0 - r0) < 1e-6 || (!transform_stroke && (fabs(w1 - r0) < 1e-6 || fabs(h1 - r0) < 1e-6))) {
 106         return (p2o * direct * o2n); // can't solve the equation: one of the dimensions is equal to stroke width, so return the straightforward scaler
 107     }
 108
 109     int flip_x = (w1 > 0) ? 1 : -1;
 110     int flip_y = (h1 > 0) ? 1 : -1;
 111
 112     // w1 and h1 will be negative when mirroring, but if so then e.g. w1-r0 won't make sense
 113     // Therefore we will use the absolute values from this point on
 114     w1 = fabs(w1);
 115     h1 = fabs(h1);
 116     r0 = fabs(r0);
 117     // w0 and h0 will always be positive due to the definition extent()
 118
 119     gdouble ratio_x = (w1 - r0) / (w0 - r0);
 120     gdouble ratio_y = (h1 - r0) / (h0 - r0);
 121
 122     Geom::Matrix direct_constant_r = Geom::Scale(flip_x * ratio_x, flip_y * ratio_y);
 123
 124     if (transform_stroke && r0 != 0 && r0 != NR_HUGE) { // there's stroke, and we need to scale it
 125         // These coefficients are obtained from the assumption that scaling applies to the
 126         // non-stroked "shape proper" and that stroke scale is scaled by the expansion of that
 127         // matrix. We're trying to solve this equation:
 128         // r1 = r0 * sqrt (((w1-r0)/(w0-r0))*((h1-r0)/(h0-r0)))
 129         // The operant of the sqrt() must be positive, which is ensured by the fabs() a few lines above
 130         gdouble A = -w0*h0 + r0*(w0 + h0);
 131         gdouble B = -(w1 + h1) * r0*r0;
 132         gdouble C = w1 * h1 * r0*r0;
 133         if (B*B - 4*A*C > 0) {
 134             gdouble r1 = fabs((-B - sqrt(B*B - 4*A*C))/(2*A));
 135             //gdouble r2 = (-B + sqrt (B*B - 4*A*C))/(2*A);
 136             //std::cout << "r0" << r0 << " r1" << r1 << " r2" << r2 << "\n";
 137             //
 138             // If w1 < 0 then the scale will be wrong if we just do
 139             // gdouble scale_x = (w1 - r1)/(w0 - r0);
 140             // Here we also need the absolute values of w0, w1, h0, h1, and r1
 141             gdouble scale_x = (w1 - r1)/(w0 - r0);
 142             gdouble scale_y = (h1 - r1)/(h0 - r0);
 143             scale *= Geom::Scale(flip_x * scale_x, flip_y * scale_y);
 144             unbudge *= Geom::Translate (-flip_x * 0.5 * (r0 * scale_x - r1), -flip_y * 0.5 * (r0 * scale_y - r1));
 145         } else {
 146             scale *= direct;
 147         }
 148     } else {
 149         if (r0 == 0 || r0 == NR_HUGE) { // no stroke to scale
 150             scale *= direct;
 151         } else {// nonscaling strokewidth
 152             scale *= direct_constant_r;
 153             unbudge *= Geom::Translate (flip_x * 0.5 * r0 * (1 - ratio_x), flip_y * 0.5 * r0 * (1 - ratio_y));
 154         }
 155     }
 156
 157     return (p2o * scale * unbudge * o2n);
 158 }
 159
 160 Geom::Rect
 161 get_visual_bbox (Geom::OptRect const &initial_geom_bbox, Geom::Matrix const &abs_affine, gdouble const initial_strokewidth, bool const transform_stroke)
 162 {
 163
 164     g_assert(initial_geom_bbox);
 165
 166     // Find the new geometric bounding box; Do this by transforming each corner of
 167     // the initial geometric bounding box individually and fitting a new boundingbox
 168     // around the transformerd corners
 169     Geom::Point const p0 = Geom::Point(initial_geom_bbox->corner(0)) * abs_affine;
 170     Geom::Rect new_geom_bbox(p0, p0);
 171     for (unsigned i = 1 ; i < 4 ; i++) {
 172         new_geom_bbox.expandTo(Geom::Point(initial_geom_bbox->corner(i)) * abs_affine);
 173     }
 174
 175     Geom::Rect new_visual_bbox = new_geom_bbox;
 176     if (initial_strokewidth > 0 && initial_strokewidth < NR_HUGE) {
 177         if (transform_stroke) {
 178             // scale stroke by: sqrt (((w1-r0)/(w0-r0))*((h1-r0)/(h0-r0))) (for visual bboxes, see get_scale_transform_with_stroke)
 179             // equals scaling by: sqrt ((w1/w0)*(h1/h0)) for geometrical bboxes
 180             // equals scaling by: sqrt (area1/area0) for geometrical bboxes
 181             gdouble const new_strokewidth = initial_strokewidth * sqrt (new_geom_bbox.area() / initial_geom_bbox->area());
 182             new_visual_bbox.expandBy(0.5 * new_strokewidth);
 183         } else {
 184             // Do not transform the stroke
 185             new_visual_bbox.expandBy(0.5 * initial_strokewidth);
 186         }
 187     }
 188
 189     return new_visual_bbox;
 190 }
 191
 192 /*
 193   Local Variables:
 194   mode:c++
 195   c-file-style:"stroustrup"
 196   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 197   indent-tabs-mode:nil
 198   fill-column:99
 199   End:
 200 */
 201 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :