Added tests to offset

benchmark/build.py

@@ -43,6 +43,7 @@ benchmarks = [
     "test_font_registration.cpp",
     "test_rendering.cpp",
     "test_rendering_shared_map.cpp",
+    "test_offset_converter.cpp",
 #    "test_numeric_cast_vs_static_cast.cpp",
 ]
 for cpp_test in benchmarks:

benchmark/run

@@ -18,9 +18,10 @@ function run {
 #run test_polygon_clipping 10 1000
 #run test_polygon_clipping_rendering 10 100
 run test_proj_transform1 10 100
-run test_expression_parse 10 10000
-run test_face_ptr_creation 10 10000
-run test_font_registration 10 1000
+run test_expression_parse 10 1000
+run test_face_ptr_creation 10 1000
+run test_font_registration 10 100
+run test_offset_converter 10 1000
 
 ./benchmark/out/test_rendering \
   --name "text rendering" \

benchmark/test_offset_converter.cpp

@@ -0,0 +1,101 @@
+#include "bench_framework.hpp"
+
+// mapnik
+#include <mapnik/global.hpp>
+#include <mapnik/coord.hpp>
+#include <mapnik/vertex.hpp>
+#include <mapnik/offset_converter.hpp>
+
+struct fake_path
+{
+    using coord_type = std::tuple<double, double, unsigned>;
+    using cont_type = std::vector<coord_type>;
+    cont_type vertices_;
+    cont_type::iterator itr_;
+
+    fake_path(std::initializer_list<double> l)
+        : fake_path(l.begin(), l.size()) {
+    }
+
+    fake_path(std::vector<double> const &v)
+        : fake_path(v.begin(), v.size()) {
+    }
+
+    template <typename Itr>
+    fake_path(Itr itr, size_t sz) {
+        size_t num_coords = sz >> 1;
+        vertices_.reserve(num_coords);
+
+        for (size_t i = 0; i < num_coords; ++i) {
+            double x = *itr++;
+            double y = *itr++;
+            unsigned cmd = (i == 0) ? mapnik::SEG_MOVETO : mapnik::SEG_LINETO;
+            vertices_.push_back(std::make_tuple(x, y, cmd));
+            if (i == num_coords - 1) cmd = mapnik::SEG_END;
+            vertices_.push_back(std::make_tuple(x, y, cmd));
+        }
+        itr_ = vertices_.begin();
+    }
+
+    unsigned vertex(double *x, double *y) {
+        if (itr_ == vertices_.end()) {
+            return mapnik::SEG_END;
+        }
+        *x = std::get<0>(*itr_);
+        *y = std::get<1>(*itr_);
+        unsigned cmd = std::get<2>(*itr_);
+        ++itr_;
+        return cmd;
+    }
+
+    void rewind(unsigned) {
+        itr_ = vertices_.begin();
+    }
+};
+
+class test_offset : public benchmark::test_case
+{
+public:
+    test_offset(mapnik::parameters const& params)
+     : test_case(params) {}
+    bool validate() const
+    {
+        return true;
+    }
+    bool operator()() const
+    {
+        std::vector<double> path;
+        int mysize = 2500;
+        int x1 = 0;
+        path.reserve(mysize*2);
+        for( int i = 0; i < mysize; i++ )
+        {
+            path.push_back( i );
+            path.push_back( 0 );
+        }
+        fake_path fpath(path);
+        for (std::size_t i=0;i<iterations_;++i) {
+            mapnik::offset_converter<fake_path> off_path(fpath);
+            off_path.set_offset(10);
+            unsigned cmd;
+            double x, y;
+            while ((cmd = off_path.vertex(&x, &y)) != mapnik::SEG_END)
+            {
+                x1++;
+            }
+        }
+        return x1 > 0;
+    }
+};
+
+
+int main(int argc, char** argv)
+{
+    mapnik::parameters params;
+    benchmark::handle_args(argc,argv,params);
+    {
+        test_offset test_runner(params);
+        run(test_runner,"offset_test");
+    }
+    return 0;
+}

test/unit/vertex_adapter/offset_converter.cpp

@@ -0,0 +1,330 @@
+#include "catch.hpp"
+
+// mapnik
+#include <mapnik/global.hpp>
+#include <mapnik/coord.hpp>
+#include <mapnik/vertex.hpp>
+#include <mapnik/offset_converter.hpp>
+
+// stl
+#include <stdexcept>
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <tuple>
+#include <algorithm>
+
+namespace offset_test {
+
+struct fake_path
+{
+    using coord_type = std::tuple<double, double, unsigned>;
+    using cont_type = std::vector<coord_type>;
+    cont_type vertices_;
+    cont_type::iterator itr_;
+
+    fake_path(std::initializer_list<double> l)
+        : fake_path(l.begin(), l.size()) {
+    }
+
+    fake_path(std::vector<double> const &v)
+        : fake_path(v.begin(), v.size()) {
+    }
+
+    template <typename Itr>
+    fake_path(Itr itr, size_t sz) {
+        size_t num_coords = sz >> 1;
+        vertices_.reserve(num_coords);
+
+        for (size_t i = 0; i < num_coords; ++i) {
+            double x = *itr++;
+            double y = *itr++;
+            unsigned cmd = (i == 0) ? mapnik::SEG_MOVETO : mapnik::SEG_LINETO;
+            vertices_.push_back(std::make_tuple(x, y, cmd));
+            if (i == num_coords - 1) cmd = mapnik::SEG_END;
+            vertices_.push_back(std::make_tuple(x, y, cmd));
+        }
+        itr_ = vertices_.begin();
+    }
+
+    unsigned vertex(double *x, double *y) {
+        if (itr_ == vertices_.end()) {
+            return mapnik::SEG_END;
+        }
+        *x = std::get<0>(*itr_);
+        *y = std::get<1>(*itr_);
+        unsigned cmd = std::get<2>(*itr_);
+        ++itr_;
+        return cmd;
+    }
+
+    void rewind(unsigned) {
+        itr_ = vertices_.begin();
+    }
+};
+
+static double DELTA_BUFF = 0.5;
+
+double dist(double x0, double y0, double x1, double y1)
+{
+    double dx = x0 - x1;
+    double dy = y0 - y1;
+    return std::sqrt(dx*dx + dy*dy);
+}
+
+void test_simple_segment(double const &offset)
+{
+    fake_path path = {0, 0, 1, 0}, off_path = {0, offset, 1, offset};
+    mapnik::offset_converter<fake_path> off_path_new(path);
+    off_path_new.set_offset(offset);
+
+    double x0, y0, x1, y1;
+    unsigned cmd0 = off_path_new.vertex(&x0, &y0);
+    unsigned cmd1 = off_path.vertex(&x1,&y1);
+    double d = dist(x0, y0, x1, y1);
+    while (true) {
+        if (d > (std::abs(offset) + DELTA_BUFF))
+        {
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            REQUIRE(cmd0 != mapnik::SEG_END);
+            d = dist(x0, y0, x1, y1);
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+        }
+        else
+        {
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+            
+        }
+        
+        cmd1 = off_path.vertex(&x1,&y1);
+        d = dist(x0, y0, x1, y1);
+        bool done = false;
+        while (d <= (std::abs(offset) + DELTA_BUFF))
+        {
+            CHECK(true);
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            if (cmd0 == mapnik::SEG_END)
+            {
+                done = true;
+                break;
+            }
+        }
+        if (done) break;
+    }
+}
+
+void test_straight_line(double const &offset) {
+    fake_path path = {0, 0, 1, 0, 9, 0, 10, 0},
+        off_path = {0, offset, 1, offset, 9, offset, 10, offset};
+    mapnik::offset_converter<fake_path> off_path_new(path);
+    off_path_new.set_offset(offset);
+
+    double x0, y0, x1, y1;
+    unsigned cmd0 = off_path_new.vertex(&x0, &y0);
+    unsigned cmd1 = off_path.vertex(&x1,&y1);
+    double d = dist(x0, y0, x1, y1);
+    while (true) {
+        if (d > (std::abs(offset) + DELTA_BUFF))
+        {
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            REQUIRE(cmd0 != mapnik::SEG_END);
+            d = dist(x0, y0, x1, y1);
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+        }
+        else
+        {
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+            
+        }
+        
+        cmd1 = off_path.vertex(&x1,&y1);
+        d = dist(x0, y0, x1, y1);
+        bool done = false;
+        while (d <= (std::abs(offset) + DELTA_BUFF))
+        {
+            CHECK(true);
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            if (cmd0 == mapnik::SEG_END)
+            {
+                done = true;
+                break;
+            }
+        }
+        if (done) break;
+    }
+}
+
+void test_offset_curve(double const &offset) {
+    const double r = (1.0 + offset);
+
+    std::vector<double> pos, off_pos;
+    const size_t max_i = 1000;
+    for (size_t i = 0; i <= max_i; ++i) {
+        double x = M_PI * double(i) / max_i;
+        pos.push_back(-std::cos(x)); pos.push_back(std::sin(x));
+        off_pos.push_back(-r * std::cos(x)); off_pos.push_back(r * std::sin(x));
+    }
+
+    fake_path path(pos), off_path(off_pos);
+    mapnik::offset_converter<fake_path> off_path_new(path);
+    off_path_new.set_offset(offset);
+
+    double x0, y0, x1, y1;
+    unsigned cmd0 = off_path_new.vertex(&x0, &y0);
+    unsigned cmd1 = off_path.vertex(&x1,&y1);
+    double d = dist(x0, y0, x1, y1);
+    while (true) {
+        if (d > (std::abs(offset) + DELTA_BUFF))
+        {
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            REQUIRE(cmd0 != mapnik::SEG_END);
+            d = dist(x0, y0, x1, y1);
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+        }
+        else
+        {
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+            
+        }
+        
+        cmd1 = off_path.vertex(&x1,&y1);
+        d = dist(x0, y0, x1, y1);
+        bool done = false;
+        while (d <= (std::abs(offset) + DELTA_BUFF))
+        {
+            CHECK(true);
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            if (cmd0 == mapnik::SEG_END)
+            {
+                done = true;
+                break;
+            }
+        }
+        if (done) break;
+    }
+}
+
+void test_s_shaped_curve(double const &offset) {
+    const double r = (1.0 + offset);
+    const double r2 = (1.0 - offset);
+
+    std::vector<double> pos, off_pos;
+    const size_t max_i = 1000;
+    for (size_t i = 0; i <= max_i; ++i) {
+        double x = M_PI * double(i) / max_i;
+        pos.push_back(-std::cos(x) - 1); pos.push_back(std::sin(x));
+        off_pos.push_back(-r * std::cos(x) - 1); off_pos.push_back(r * std::sin(x));
+    }
+    for (size_t i = 0; i <= max_i; ++i) {
+        double x = M_PI * double(i) / max_i;
+        pos.push_back(-std::cos(x) + 1); pos.push_back(-std::sin(x));
+        off_pos.push_back(-r2 * std::cos(x) + 1); off_pos.push_back(-r2 * std::sin(x));
+    }
+
+    fake_path path(pos), off_path(off_pos);
+    mapnik::offset_converter<fake_path> off_path_new(path);
+    off_path_new.set_offset(offset);
+
+    double x0, y0, x1, y1;
+    unsigned cmd0 = off_path_new.vertex(&x0, &y0);
+    unsigned cmd1 = off_path.vertex(&x1,&y1);
+    double d = dist(x0, y0, x1, y1);
+    while (true) {
+        if (d > (std::abs(offset) + DELTA_BUFF))
+        {
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            REQUIRE(cmd0 != mapnik::SEG_END);
+            d = dist(x0, y0, x1, y1);
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+        }
+        else
+        {
+            REQUIRE(d <= (std::abs(offset) + DELTA_BUFF));
+            
+        }
+        
+        cmd1 = off_path.vertex(&x1,&y1);
+        d = dist(x0, y0, x1, y1);
+        bool done = false;
+        while (d <= (std::abs(offset) + DELTA_BUFF))
+        {
+            CHECK(true);
+            cmd0 = off_path_new.vertex(&x0,&y0);
+            if (cmd0 == mapnik::SEG_END)
+            {
+                done = true;
+                break;
+            }
+        }
+        if (done) break;
+    }
+}
+
+} // END NS
+
+TEST_CASE("offset converter") {
+
+SECTION("simple segment") {
+    try {
+
+        std::vector<double> offsets = { 1, -1 };
+        for (double offset : offsets) {
+            // test simple straight line segment - should be easy to
+            // find the correspondance here.
+            offset_test::test_simple_segment(offset);
+        }
+    }
+    catch (std::exception const& ex)
+    {
+        std::cerr << ex.what() << "\n";
+        REQUIRE(false);
+    }
+}
+
+SECTION("straight line") {
+    try {
+
+        std::vector<double> offsets = { 1, -1 };
+        for (double offset : offsets) {
+            // test straight line consisting of more than one segment.
+            offset_test::test_straight_line(offset);
+        }
+    }
+    catch (std::exception const& ex)
+    {
+        std::cerr << ex.what() << "\n";
+        REQUIRE(false);
+    }
+}
+
+SECTION("curve") {
+    try {
+
+        std::vector<double> offsets = { 1, -1 };
+        for (double offset : offsets) {
+            offset_test::test_offset_curve(offset);
+        }
+    }
+    catch (std::exception const& ex)
+    {
+        std::cerr << ex.what() << "\n";
+        REQUIRE(false);
+    }
+}
+
+SECTION("s curve") {
+    try {
+
+        std::vector<double> offsets = { 1, -1 };
+        for (double offset : offsets) {
+            offset_test::test_s_shaped_curve(offset);
+        }
+    }
+    catch (std::exception const& ex)
+    {
+        std::cerr << ex.what() << "\n";
+        REQUIRE(false);
+    }
+}
+
+}