archive-gh-me/mapnik
1
0
Fork 0
mirror of https://github.com/mapnik/mapnik.git synced 2025-12-08 20:13:09 +00:00
Code Issues Projects Releases Wiki Activity

visual tests: add time measurement

Browse Source
This commit is contained in:
Jiri Drbalek 2015-07-07 12:35:28 +00:00
parent d13543c359
commit 1fa6cc73db
7 changed files with 71 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/visual/config.hpp
View File

@ -26,6 +26,7 @@
// stl
#include <vector>
#include <string>
#include <chrono>
// boost
#include <boost/filesystem.hpp>
@ -74,6 +75,7 @@ struct result
boost::filesystem::path reference_image_path;
std::string error_message;
unsigned diff;
std::chrono::high_resolution_clock::duration duration;
};
using result_list = std::vector<result>;

12
test/visual/renderer.hpp
View File

@ -237,20 +237,18 @@ public:
{
}
result test(std::string const & name, mapnik::Map const & map, double scale_factor) const
image_type render(mapnik::Map const & map, double scale_factor) const
{
image_type image(ren.render(map, scale_factor));
return report(image, name, { map.width(), map.height() }, { 1, 1 }, scale_factor);
return ren.render(map, scale_factor);
}
result test_tiles(std::string const & name, mapnik::Map & map, map_size const & tiles, double scale_factor) const
image_type render(mapnik::Map & map, double scale_factor, map_size const & tiles) const
{
image_type image(map.width(), map.height());
mapnik::box2d<double> box = map.get_current_extent();
image_type image(map.width(), map.height());
map.resize(image.width() / tiles.width, image.height() / tiles.height);
double tile_box_width = box.width() / tiles.width;
double tile_box_height = box.height() / tiles.height;
for (std::size_t tile_y = 0; tile_y < tiles.height; tile_y++)
{
for (std::size_t tile_x = 0; tile_x < tiles.width; tile_x++)
@ -265,7 +263,7 @@ public:
set_rectangle(tile, image, tile_x * tile.width(), (tiles.height - 1 - tile_y) * tile.height());
}
}
return report(image, name, { image.width(), image.height() }, tiles, scale_factor);
return image;
}
result report(image_type const & image,

5
test/visual/report.cpp
View File

@ -55,6 +55,11 @@ void console_report::report(result const & r)
break;
}
if (show_duration)
{
s << " (" << std::chrono::duration_cast<std::chrono::milliseconds>(r.duration).count() << " milliseconds)";
}
s << std::endl;
}

5
test/visual/report.hpp
View File

@ -36,7 +36,7 @@ namespace visual_tests
class console_report
{
public:
console_report() : s(std::clog)
console_report(bool _show_duration) : s(std::clog), show_duration(_show_duration)
{
}
@ -49,12 +49,13 @@ public:
protected:
std::ostream & s;
bool show_duration;
};
class console_short_report : public console_report
{
public:
console_short_report() : console_report()
console_short_report() : console_report(false)
{
}

7
test/visual/run.cpp
View File

@ -53,6 +53,8 @@ int main(int argc, char** argv)
("help,h", "produce usage message")
("verbose,v", "verbose output")
("overwrite,o", "overwrite reference image")
("duration,d", "output rendering duration")
("iterations,i", po::value<std::size_t>()->default_value(1), "number of iterations for benchmarking")
("jobs,j", po::value<std::size_t>()->default_value(1), "number of parallel threads")
("styles-dir", po::value<std::string>()->default_value("test/data-visual/styles"), "directory with styles")
("images-dir", po::value<std::string>()->default_value("test/data-visual/images"), "directory with reference images")
@ -108,8 +110,11 @@ int main(int argc, char** argv)
output_dir,
vm["images-dir"].as<std::string>(),
vm.count("overwrite"),
vm["iterations"].as<std::size_t>(),
vm["jobs"].as<std::size_t>());
report_type report = vm.count("verbose") ? report_type((console_report())) : report_type((console_short_report()));
bool show_duration = vm.count("duration");
bool verbose = vm.count("verbose") | show_duration;
report_type report(verbose ? report_type((console_report(show_duration))) : report_type((console_short_report())));
result_list results;
try

65
test/visual/runner.cpp
View File

@ -39,30 +39,22 @@ public:
map_size const & tiles,
double scale_factor,
result_list & results,
report_type & report)
report_type & report,
std::size_t iterations)
: name_(name),
map_(map),
tiles_(tiles),
scale_factor_(scale_factor),
results_(results),
report_(report)
report_(report),
iterations_(iterations)
{
}
template <typename T, typename std::enable_if<T::renderer_type::support_tiles>::type* = nullptr>
void operator()(T const & renderer)
{
result r;
if (tiles_.width == 1 && tiles_.height == 1)
{
r = renderer.test(name_, map_, scale_factor_);
}
else
{
r = renderer.test_tiles(name_, map_, tiles_, scale_factor_);
}
mapnik::util::apply_visitor(report_visitor(r), report_);
results_.push_back(std::move(r));
test(renderer);
}
template <typename T, typename std::enable_if<!T::renderer_type::support_tiles>::type* = nullptr>
@ -70,30 +62,69 @@ public:
{
if (tiles_.width == 1 && tiles_.height == 1)
{
result r = renderer.test(name_, map_, scale_factor_);
mapnik::util::apply_visitor(report_visitor(r), report_);
results_.push_back(std::move(r));
test(renderer);
}
}
private:
template <typename T>
void test(T const & renderer)
{
map_size size { map_.width(), map_.height() };
std::chrono::high_resolution_clock::time_point start(std::chrono::high_resolution_clock::now());
for (std::size_t i = iterations_ ; i > 0; i--)
{
typename T::image_type image(render(renderer));
if (i == 1)
{
std::chrono::high_resolution_clock::time_point end(std::chrono::high_resolution_clock::now());
result r(renderer.report(image, name_, size, tiles_, scale_factor_));
r.duration = end - start;
mapnik::util::apply_visitor(report_visitor(r), report_);
results_.push_back(std::move(r));
}
}
}
template <typename T, typename std::enable_if<T::renderer_type::support_tiles>::type* = nullptr>
typename T::image_type render(T const & renderer)
{
if (tiles_.width == 1 && tiles_.height == 1)
{
return renderer.render(map_, scale_factor_);
}
else
{
return renderer.render(map_, scale_factor_, tiles_);
}
}
template <typename T, typename std::enable_if<!T::renderer_type::support_tiles>::type* = nullptr>
typename T::image_type render(T const & renderer)
{
return renderer.render(map_, scale_factor_);
}
std::string const & name_;
mapnik::Map & map_;
map_size const & tiles_;
double scale_factor_;
result_list & results_;
report_type & report_;
std::size_t iterations_;
};
runner::runner(runner::path_type const & styles_dir,
runner::path_type const & output_dir,
runner::path_type const & reference_dir,
bool overwrite,
std::size_t iterations,
std::size_t jobs)
: styles_dir_(styles_dir),
output_dir_(output_dir),
reference_dir_(reference_dir),
jobs_(jobs),
iterations_(iterations),
renderers_{ renderer<agg_renderer>(output_dir_, reference_dir_, overwrite)
#if defined(HAVE_CAIRO)
,renderer<cairo_renderer>(output_dir_, reference_dir_, overwrite)
@ -286,7 +317,7 @@ result_list runner::test_one(runner::path_type const& style_path, config cfg, re
{
map.zoom_all();
}
mapnik::util::apply_visitor(renderer_visitor(name, map, tiles_count, scale_factor, results, report), ren);
mapnik::util::apply_visitor(renderer_visitor(name, map, tiles_count, scale_factor, results, report, iterations_), ren);
}
}
}

2
test/visual/runner.hpp
View File

@ -54,6 +54,7 @@ public:
path_type const & output_dir,
path_type const & reference_dir,
bool overwrite,
std::size_t iterations,
std::size_t jobs);
result_list test_all(report_type & report) const;
@ -70,6 +71,7 @@ private:
const path_type output_dir_;
const path_type reference_dir_;
const std::size_t jobs_;
const std::size_t iterations_;
const renderer_type renderers_[boost::mpl::size<renderer_type::types>::value];
};