What define's Boost's svg_mapper scaling and translation?

Question

This code:

#include 

#include 
#include 
#include 

namespace bg = boost::geometry;

int main()
{
    std::ofstream svg ( "test.svg" );
    boost::geometry::svg_mapper, true, double> mapper ( svg, 6000, 3000 );

    bg::model::polygon> square{
        {{0, 0}, {0, 1000}, {1000, 1000}, {1000, 0}, {0, 0}}};
    const std::string style{"fill-opacity:1.0;fill:rgb(128,128,128);stroke:rgb(0,0,0);stroke-width:5"};

    mapper.add ( square );
    mapper.map ( square, style, 1.0 );
}

Produces this svg:

The following conversions happen from the input polygon to the mapped svg geometries:

(0, 0) -> (1500,3000)
(0, 1000) -> (1500,0)
(1000, 1000) -> (4500,0)
(1000, 0) -> (4500,3000)
(0, 0) -> (1500,3000)

Staring at it a bit you see there is some transformation applied, something like this:

+1500 in x
+3000 in y
3x scale in x
-3x scale in y

My question is - What drives that transformation and can I prevent it? And if I can't prevent it, can I retrieve it or calculate it myself?

Reason being is I'm producing many complex SVG's and would like them to all be in the same frame. So if there is a circle at pixels (10,10) in one, I would like all the images to be of the same size with the circle in the exact same location. I tried to accomplish this with viewBox but the scaling and translation was too hard to predict to keep the images consistent.

user_85371 · Answer

svg_mapper calculates a bounding box from all add-ed geometries.

Then, a map_transformer is used to scale down to the desired width/height.

Contrary to what you might expect, add doesn't do anything besides expanding the bounding box. Likewise, after the first map call, no other add has any effect on the bounding-box used for the transformations.

In other words, you can use some kind of fixed bounding box, add only that, and then map your geometries into that "canvas":

Demo

#include 
#include 

#include 
#include 
#include 

namespace bg = boost::geometry;
using V      = /*long*/ double;
using P      = bg::model::d2::point_xy;
using B      = bg::model::box;

int main()
{
    auto verify = [](auto& g) {
        if (std::string r; !bg::is_valid(g, r)) {
            std::cout << "Correcting " << r << "
";
            bg::correct(g);
        }
    };

    V side = 1000;
    bg::model::polygon square{
        {{0, 0}, {0, side}, {side, side}, {side, 0}, {0, 0}},
    };

    verify(square);

    std::array steps {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,};
    for (unsigned i = 0; i < steps.size(); ++i) {
        {
            std::ofstream svg("test" + std::to_string(i) + ".svg");
            bg::svg_mapper mapper(svg, 400, 400);

            auto clone = square;
            V    ofs   = (steps[i] / 5. - 1.0) * side;
            for (auto& p : boost::make_iterator_range(bg::points_begin(clone), bg::points_end(clone)))
                bg::add_point(p, P{ofs, ofs});
            std::cout << i << ": " << bg::wkt(square) << " " << bg::wkt(clone) << "
";

            mapper.add(B{{-side, -side}, {2 * side, 2 * side}});
            //mapper.add(square); // no effect, already within bounding box
            //mapper.add(clone);  // no effect, already within bounding box
            mapper.map(square, "fill-opacity:0.1;fill:rgb(128,0,0)", 1.0);
            mapper.map(clone,  "fill-opacity:0.1;fill:rgb(0,0,128)", 1.0);
        }
    }
}

Which creates a series of svgs that I can show as a poor man's animation to show that the positioning of the square is constant:

What define's Boost's svg_mapper scaling and translation?

1 Answers