Skip to content

Commit

Permalink
Merge pull request #1246 from mirecta/transform_expr
Browse files Browse the repository at this point in the history 
set transform expression from python
  • Loading branch information
@artemp
artemp committed Jun 7, 2012
2 parents 03e6f9d + 2a76346 commit 51650b0
Show file tree
Hide file tree
Showing 7 changed files with 276 additions and 221 deletions.
15 changes: 3 additions & 12 deletions bindings/python/mapnik_svg.hpp
View file
Expand Up @@ -25,15 +25,8 @@
// mapnik // mapnik
#include <mapnik/parse_transform.hpp> #include <mapnik/parse_transform.hpp>
#include <mapnik/symbolizer.hpp> #include <mapnik/symbolizer.hpp>
#include <mapnik/svg/svg_path_parser.hpp>
#include <mapnik/value_error.hpp> #include <mapnik/value_error.hpp>


// boost
#include <boost/make_shared.hpp>

// agg
#include "agg_trans_affine.h"

namespace mapnik { namespace mapnik {
using namespace boost::python; using namespace boost::python;


Expand All @@ -46,18 +39,16 @@ const std::string get_svg_transform(T& symbolizer)
template <class T> template <class T>
void set_svg_transform(T& symbolizer, std::string const& transform_wkt) void set_svg_transform(T& symbolizer, std::string const& transform_wkt)
{ {
agg::trans_affine tr; transform_list_ptr trans_expr = mapnik::parse_transform(transform_wkt);
if (!mapnik::svg::parse_transform(transform_wkt.c_str(), tr)) if (!trans_expr)
{ {
std::stringstream ss; std::stringstream ss;
ss << "Could not parse transform from '" ss << "Could not parse transform from '"
<< transform_wkt << transform_wkt
<< "', expected SVG transform attribute"; << "', expected SVG transform attribute";
throw mapnik::value_error(ss.str()); throw mapnik::value_error(ss.str());
} }
transform_list_ptr trans = boost::make_shared<transform_list>(); symbolizer.set_image_transform(trans_expr);
trans->push_back(matrix_node(tr));
symbolizer.set_image_transform(trans);
} }


} // end of namespace mapnik } // end of namespace mapnik
Expand Down
2 changes: 1 addition & 1 deletion include/mapnik/attribute_collector.hpp
View file
Expand Up @@ -25,7 +25,7 @@


// mapnik // mapnik
#include <mapnik/rule.hpp> #include <mapnik/rule.hpp>
#include <mapnik/parse_transform.hpp> #include <mapnik/transform_processor.hpp>
// boost // boost
#include <boost/utility.hpp> #include <boost/utility.hpp>
#include <boost/variant.hpp> #include <boost/variant.hpp>
Expand Down
211 changes: 8 additions & 203 deletions include/mapnik/parse_transform.hpp
View file
Expand Up @@ -25,218 +25,23 @@


// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/attribute.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/value.hpp>
#include <mapnik/transform_expression.hpp> #include <mapnik/transform_expression.hpp>
#include <mapnik/expression_evaluator.hpp>

// boost
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/foreach.hpp>

// agg
#include <agg_trans_affine.h>


namespace mapnik { namespace mapnik {


template <typename Container> struct expression_attributes;
template <typename Iterator> struct transform_expression_grammar; template <typename Iterator> struct transform_expression_grammar;


MAPNIK_DECL transform_list_ptr parse_transform(std::string const & str); typedef transform_expression_grammar<std::string::const_iterator>
MAPNIK_DECL bool parse_transform(transform_list& list, transform_expression_grammar__string;
std::string const & str,
transform_expression_grammar<std::string::const_iterator> const& g);


template <typename T>
struct transform_processor
{
typedef T feature_type;
typedef agg::trans_affine transform_type;

template <typename Container>
struct attribute_collector : boost::static_visitor<void>
{
expression_attributes<Container> collect_;

attribute_collector(Container& names)
: collect_(names) {}

void operator() (identity_node const& node) const
{
boost::ignore_unused_variable_warning(node);
}

void operator() (matrix_node const& node) const
{
boost::apply_visitor(collect_, node.a_);
boost::apply_visitor(collect_, node.b_);
boost::apply_visitor(collect_, node.c_);
boost::apply_visitor(collect_, node.d_);
boost::apply_visitor(collect_, node.e_);
boost::apply_visitor(collect_, node.f_);
}

void operator() (translate_node const& node) const
{
boost::apply_visitor(collect_, node.tx_);
boost::apply_visitor(collect_, node.ty_);
}

void operator() (scale_node const& node) const
{
boost::apply_visitor(collect_, node.sx_);
boost::apply_visitor(collect_, node.sy_);
}

void operator() (rotate_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
boost::apply_visitor(collect_, node.cx_);
boost::apply_visitor(collect_, node.cy_);
}

void operator() (skewX_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}

void operator() (skewY_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}
};

struct node_evaluator : boost::static_visitor<void>
{
node_evaluator(transform_type& tr, feature_type const& feat)
: transform_(tr), feature_(feat) {}

void operator() (identity_node const& node)
{
boost::ignore_unused_variable_warning(node);
}

void operator() (matrix_node const& node)
{
double a = eval(node.a_);
double b = eval(node.b_);
double c = eval(node.c_);
double d = eval(node.d_);
double e = eval(node.e_);
double f = eval(node.f_);
transform_.multiply(agg::trans_affine(a, b, c, d, e, f));
}


void operator() (translate_node const& node) MAPNIK_DECL transform_list_ptr parse_transform(std::string const& str);
{
double tx = eval(node.tx_);
double ty = eval(node.ty_, 0.0);
transform_.translate(tx, ty);
}


void operator() (scale_node const& node) MAPNIK_DECL transform_list_ptr parse_transform(std::string const& str,
{ std::string const& encoding);
double sx = eval(node.sx_);
double sy = eval(node.sy_, sx);
transform_.scale(sx, sy);
}


void operator() (rotate_node const& node) MAPNIK_DECL bool parse_transform(transform_list& list,
{ std::string const& str,
double angle = deg2rad(eval(node.angle_)); transform_expression_grammar__string const& g);
double cx = eval(node.cx_, 0.0);
double cy = eval(node.cy_, 0.0);
transform_.translate(-cx, -cy);
transform_.rotate(angle);
transform_.translate(cx, cy);
}

void operator() (skewX_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(angle, 0.0));
}

void operator() (skewY_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(0.0, angle));
}

private:

static double deg2rad(double d)
{
return d * M_PI / 180.0;
}

double eval(expr_node const& x) const
{
mapnik::evaluate<feature_type, value_type> e(feature_);
return boost::apply_visitor(e, x).to_double();
}

double eval(expr_node const& x, double def) const
{
return is_null(x) ? def : eval(x);
}

transform_type& transform_;
feature_type const& feature_;
};

template <typename Container>
static void collect_attributes(Container& names,
transform_list const& list)
{
attribute_collector<Container> collect(names);

BOOST_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(collect, *node);
}
}

static void evaluate(transform_type& tr, feature_type const& feat,
transform_list const& list)
{
node_evaluator eval(tr, feat);

#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: begin with " << to_string(matrix_node(tr));
#endif

BOOST_REVERSE_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(eval, *node);
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: apply " << to_string(*node);
MAPNIK_LOG_DEBUG(transform) << "transform: result " << to_string(matrix_node(tr));
#endif
}

#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: end";
#endif
}

static std::string to_string(transform_node const& node)
{
return to_expression_string(node);
}

static std::string to_string(transform_list const& list)
{
return to_expression_string(list);
}
};

typedef mapnik::transform_processor<Feature> transform_processor_type;


} // namespace mapnik } // namespace mapnik


Expand Down

0 comments on commit 51650b0

Please sign in to comment.