sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move vertex_cache functions from .hpp to .cpp.

Browse source
This commit is contained in:
Hermann Kraus 2013-03-30 12:45:46 +01:00
parent e544dca6c1
commit d7553fb93c
3 changed files with 198 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

192
include/mapnik/vertex_cache.hpp
View file

@ -25,19 +25,17 @@
// mapnik
#include <mapnik/pixel_position.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/offset_converter.hpp>
// agg
#include "agg_basics.h"
// stl
#include <vector>
#include <utility>
#include <cmath>
//#include <utility>
//#include <cmath>
//boost
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
namespace mapnik
{
@ -62,6 +60,7 @@ class vertex_cache
std::vector<segment> vector;
double length;
};
public:
/** This class has no public members to avoid acciedential modification.
* It should only be used with save_state/restore_state. */
@ -90,15 +89,16 @@ public:
bool restored_;
};
/********************************************************************************************/
template <typename T> vertex_cache(T &path);
double length() const { return current_subpath_->length; }
pixel_position const& current_position() const { return current_position_; }
pixel_position const& current_position() const { return current_position_; }
double angle(double width=0.);
bool next_subpath();
/** Moves all positions to a parallel line in the specified distance. */
vertex_cache &get_offseted(double offset, double region_width);
@ -112,16 +112,19 @@ public:
bool forward(double length);
bool backward(double length);
bool move(double length); //Move works in both directions
void rewind_subpath();
bool next_subpath();
// Compatibility with standard path interface
void rewind(unsigned);
unsigned vertex(double *x, double *y);
//State
state save_state() const;
void restore_state(state const& s);
private:
void rewind_subpath();
bool next_segment();
bool previous_segment();
pixel_position current_position_;
@ -198,182 +201,7 @@ vertex_cache::vertex_cache(T &path)
}
}
double vertex_cache::angle(double width)
{
/* IMPORTANT NOTE: See note about coordinate systems in placement_finder::find_point_placement()
* for imformation about why the y axis is inverted! */
double tmp = width + position_in_segment_;
if ((tmp <= current_segment_->length) && (tmp >= 0))
{
//Only calculate angle on request as it is expensive
if (!angle_valid_)
{
angle_ = atan2(-(current_segment_->pos.y - segment_starting_point_.y),
current_segment_->pos.x - segment_starting_point_.x);
}
return width >= 0 ? angle_ : angle_ + M_PI;
} else
{
scoped_state s(*this);
pixel_position const& old_pos = s.get_state().position();
move(width);
double angle = atan2(-(current_position_.y - old_pos.y),
current_position_.x - old_pos.x);
return angle;
}
}
bool vertex_cache::next_subpath()
{
if (first_subpath_)
{
current_subpath_ = subpaths_.begin();
first_subpath_ = false;
} else
{
current_subpath_++;
}
if (current_subpath_ == subpaths_.end()) return false;
rewind_subpath();
return true;
}
bool vertex_cache::next_segment()
{
segment_starting_point_ = current_segment_->pos; //Next segments starts at the end of the current one
if (current_segment_ == current_subpath_->vector.end()) return false;
current_segment_++;
angle_valid_ = false;
if (current_segment_ == current_subpath_->vector.end()) return false;
return true;
}
bool vertex_cache::previous_segment()
{
if (current_segment_ == current_subpath_->vector.begin()) return false;
current_segment_--;
angle_valid_ = false;
if (current_segment_ == current_subpath_->vector.begin())
{
//First segment is special
segment_starting_point_ = current_segment_->pos;
return true;
}
segment_starting_point_ = (current_segment_-1)->pos;
return true;
}
vertex_cache & vertex_cache::get_offseted(double offset, double region_width)
{
if (fabs(offset) < 0.01)
{
return *this;
}
//TODO: Cache offseted lines
offset_converter<vertex_cache> converter(*this);
converter.set_offset(offset);
offseted_line_ = vertex_cache_ptr(new vertex_cache(converter));
offseted_line_->rewind_subpath(); //TODO: Multiple subpath support
double seek = (position_ + region_width/2.) * offseted_line_->length() / length() - region_width/2.;
if (seek < 0) seek = 0;
if (seek > offseted_line_->length()) seek = offseted_line_->length();
offseted_line_->move(seek);
return *offseted_line_;
}
bool vertex_cache::forward(double length)
{
if (length < 0)
{
MAPNIK_LOG_ERROR(vertex_cache) << "vertex_cache::forward() called with negative argument!\n";
return false;
}
return move(length);
}
bool vertex_cache::backward(double length)
{
if (length < 0)
{
MAPNIK_LOG_ERROR(vertex_cache) << "vertex_cache::backward() called with negative argument!\n";
return false;
}
return move(-length);
}
bool vertex_cache::move(double length)
{
position_ += length;
length += position_in_segment_;
while (length >= current_segment_->length)
{
length -= current_segment_->length;
if (!next_segment()) return false; //Skip all complete segments
}
while (length < 0)
{
if (!previous_segment()) return false;
length += current_segment_->length;
}
double factor = length / current_segment_->length;
position_in_segment_ = length;
current_position_ = segment_starting_point_ + (current_segment_->pos - segment_starting_point_) * factor;
return true;
}
void vertex_cache::rewind_subpath()
{
current_segment_ = current_subpath_->vector.begin();
//All subpaths contain at least one segment
current_position_ = current_segment_->pos;
position_in_segment_ = 0;
segment_starting_point_ = current_position_;
angle_valid_ = false;
position_ = 0;
}
void vertex_cache::rewind(unsigned)
{
vertex_subpath_ = subpaths_.begin();
vertex_segment_ = vertex_subpath_->vector.begin();
}
unsigned vertex_cache::vertex(double *x, double *y)
{
if (vertex_segment_ == vertex_subpath_->vector.end())
{
vertex_subpath_++;
if (vertex_subpath_ == subpaths_.end()) return agg::path_cmd_stop;
vertex_segment_ = vertex_subpath_->vector.begin();
}
*x = vertex_segment_->pos.x;
*y = vertex_segment_->pos.y;
unsigned cmd = (vertex_segment_ == vertex_subpath_->vector.begin()) ? agg::path_cmd_move_to : agg::path_cmd_line_to;
vertex_segment_++;
return cmd;
}
vertex_cache::state vertex_cache::save_state() const
{
state s;
s.current_segment = current_segment_;
s.position_in_segment = position_in_segment_;
s.current_position = current_position_;
s.segment_starting_point = segment_starting_point_;
s.position_ = position_;
return s;
}
void vertex_cache::restore_state(state const& s)
{
current_segment_ = s.current_segment;
position_in_segment_ = s.position_in_segment;
current_position_ = s.current_position;
segment_starting_point_ = s.segment_starting_point;
position_ = s.position_;
angle_valid_ = false;
}
}

1
src/build.py
View file

@ -179,6 +179,7 @@ source = Split(
xml_tree.cpp
config_error.cpp
color_factory.cpp
vertex_cache.cpp
warp.cpp
svg/svg_parser.cpp
svg/svg_path_parser.cpp

187
src/vertex_cache.cpp Normal file
View file

@ -0,0 +1,187 @@
#include <mapnik/vertex_cache.hpp>
#include <mapnik/offset_converter.hpp>
#include <boost/make_shared.hpp>
namespace mapnik
{
double vertex_cache::angle(double width)
{
/* IMPORTANT NOTE: See note about coordinate systems in placement_finder::find_point_placement()
* for imformation about why the y axis is inverted! */
double tmp = width + position_in_segment_;
if ((tmp <= current_segment_->length) && (tmp >= 0))
{
//Only calculate angle on request as it is expensive
if (!angle_valid_)
{
angle_ = atan2(-(current_segment_->pos.y - segment_starting_point_.y),
current_segment_->pos.x - segment_starting_point_.x);
}
return width >= 0 ? angle_ : angle_ + M_PI;
} else
{
scoped_state s(*this);
pixel_position const& old_pos = s.get_state().position();
move(width);
double angle = atan2(-(current_position_.y - old_pos.y),
current_position_.x - old_pos.x);
return angle;
}
}
bool vertex_cache::next_subpath()
{
if (first_subpath_)
{
current_subpath_ = subpaths_.begin();
first_subpath_ = false;
} else
{
current_subpath_++;
}
if (current_subpath_ == subpaths_.end()) return false;
rewind_subpath();
return true;
}
bool vertex_cache::next_segment()
{
segment_starting_point_ = current_segment_->pos; //Next segments starts at the end of the current one
if (current_segment_ == current_subpath_->vector.end()) return false;
current_segment_++;
angle_valid_ = false;
if (current_segment_ == current_subpath_->vector.end()) return false;
return true;
}
bool vertex_cache::previous_segment()
{
if (current_segment_ == current_subpath_->vector.begin()) return false;
current_segment_--;
angle_valid_ = false;
if (current_segment_ == current_subpath_->vector.begin())
{
//First segment is special
segment_starting_point_ = current_segment_->pos;
return true;
}
segment_starting_point_ = (current_segment_-1)->pos;
return true;
}
vertex_cache & vertex_cache::get_offseted(double offset, double region_width)
{
if (fabs(offset) < 0.01)
{
return *this;
}
std::cout << "Creating new offseted line: " << offset << "\n";
//TODO: Cache offseted lines
offset_converter<vertex_cache> converter(*this);
converter.set_offset(offset);
offseted_line_ = vertex_cache_ptr(new vertex_cache(converter));
offseted_line_->rewind_subpath(); //TODO: Multiple subpath support
double seek = (position_ + region_width/2.) * offseted_line_->length() / length() - region_width/2.;
if (seek < 0) seek = 0;
if (seek > offseted_line_->length()) seek = offseted_line_->length();
offseted_line_->move(seek);
return *offseted_line_;
}
bool vertex_cache::forward(double length)
{
if (length < 0)
{
MAPNIK_LOG_ERROR(vertex_cache) << "vertex_cache::forward() called with negative argument!\n";
return false;
}
return move(length);
}
bool vertex_cache::backward(double length)
{
if (length < 0)
{
MAPNIK_LOG_ERROR(vertex_cache) << "vertex_cache::backward() called with negative argument!\n";
return false;
}
return move(-length);
}
bool vertex_cache::move(double length)
{
position_ += length;
length += position_in_segment_;
while (length >= current_segment_->length)
{
length -= current_segment_->length;
if (!next_segment()) return false; //Skip all complete segments
}
while (length < 0)
{
if (!previous_segment()) return false;
length += current_segment_->length;
}
double factor = length / current_segment_->length;
position_in_segment_ = length;
current_position_ = segment_starting_point_ + (current_segment_->pos - segment_starting_point_) * factor;
return true;
}
void vertex_cache::rewind_subpath()
{
current_segment_ = current_subpath_->vector.begin();
//All subpaths contain at least one segment
current_position_ = current_segment_->pos;
position_in_segment_ = 0;
segment_starting_point_ = current_position_;
angle_valid_ = false;
position_ = 0;
}
void vertex_cache::rewind(unsigned)
{
vertex_subpath_ = subpaths_.begin();
vertex_segment_ = vertex_subpath_->vector.begin();
}
unsigned vertex_cache::vertex(double *x, double *y)
{
if (vertex_segment_ == vertex_subpath_->vector.end())
{
vertex_subpath_++;
if (vertex_subpath_ == subpaths_.end()) return agg::path_cmd_stop;
vertex_segment_ = vertex_subpath_->vector.begin();
}
*x = vertex_segment_->pos.x;
*y = vertex_segment_->pos.y;
unsigned cmd = (vertex_segment_ == vertex_subpath_->vector.begin()) ? agg::path_cmd_move_to : agg::path_cmd_line_to;
vertex_segment_++;
return cmd;
}
vertex_cache::state vertex_cache::save_state() const
{
state s;
s.current_segment = current_segment_;
s.position_in_segment = position_in_segment_;
s.current_position = current_position_;
s.segment_starting_point = segment_starting_point_;
s.position_ = position_;
return s;
}
void vertex_cache::restore_state(state const& s)
{
current_segment_ = s.current_segment;
position_in_segment_ = s.position_in_segment;
current_position_ = s.current_position;
segment_starting_point_ = s.segment_starting_point;
position_ = s.position_;
angle_valid_ = false;
}
} //ns mapnik