moved vertex_vector to classes that needed it

This commit is contained in:
Artem Pavlenko 2005-12-23 12:22:09 +00:00
parent ec9b301364
commit 30c713d639

View file

@ -27,6 +27,7 @@
#include "geom_util.hpp" #include "geom_util.hpp"
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
namespace mapnik namespace mapnik
{ {
@ -36,36 +37,107 @@ namespace mapnik
Polygon = 3, Polygon = 3,
}; };
template <typename T,template <typename> class Container=vertex_vector> template <typename T>
class geometry class geometry : private boost::noncopyable
{ {
public: public:
typedef T vertex_type; typedef T vertex_type;
typedef typename vertex_type::type value_type; typedef typename vertex_type::type value_type;
typedef Container<vertex_type> container_type;
private: private:
int srid_; int srid_;
mutable unsigned itr_;
protected:
container_type cont_;
public: public:
geometry (int srid=-1) geometry (int srid=-1)
: srid_(srid), : srid_(srid) {}
itr_(0),
cont_() {}
virtual int type() const=0;
virtual bool hit_test(value_type x,value_type y) const=0;
int srid() const int srid() const
{ {
return srid_; return srid_;
} }
virtual int type() const=0;
virtual bool hit_test(value_type x,value_type y) const=0;
virtual void move_to(value_type x,value_type y)=0;
virtual void line_to(value_type x,value_type y)=0;
virtual void transform(const mapnik::CoordTransform& t)=0;
virtual unsigned num_points() const = 0;
virtual unsigned vertex(double* x, double* y)=0;
virtual void rewind(unsigned )=0;
virtual ~geometry() {}
};
template <typename T>
class point : public geometry<T>
{
typedef geometry<T> geometry_base;
typedef typename geometry<T>::vertex_type vertex_type;
typedef typename geometry<T>::value_type value_type;
private:
vertex_type pt_;
public:
point(int srid)
: geometry<T>(srid)
{}
int type() const
{
return Point;
}
void move_to(value_type x,value_type y) void move_to(value_type x,value_type y)
{ {
cont_.push_back(x,y,SEG_MOVETO); pt_.x = x;
pt_.y = y;
}
void line_to(value_type ,value_type ) {}
void transform(const mapnik::CoordTransform& t)
{
t.forward_x(&pt_.x);
t.forward_y(&pt_.y);
}
unsigned num_points() const
{
return 1;
}
unsigned vertex(double* x, double* y)
{
*x = pt_.x;
*y = pt_.y;
return SEG_LINETO;
}
void rewind(unsigned ) {}
bool hit_test(value_type x,value_type y) const
{
return false;
}
virtual ~point() {}
};
template <typename T, template <typename> class Container=vertex_vector>
class polygon : public geometry<T>
{
typedef geometry<T> geometry_base;
typedef typename geometry<T>::vertex_type vertex_type;
typedef typename geometry_base::value_type value_type;
typedef Container<vertex_type> container_type;
private:
container_type cont_;
mutable unsigned itr_;
public:
polygon(int srid)
: geometry_base(srid),
itr_(0)
{}
int type() const
{
return Polygon;
} }
void line_to(value_type x,value_type y) void line_to(value_type x,value_type y)
@ -73,95 +145,21 @@ namespace mapnik
cont_.push_back(x,y,SEG_LINETO); cont_.push_back(x,y,SEG_LINETO);
} }
template <typename Transform> void move_to(value_type x,value_type y)
class path_iterator
{ {
typedef vertex<typename Transform::return_type,2> vertex_type; cont_.push_back(x,y,SEG_MOVETO);
const container_type* cont_;
unsigned pos_;
unsigned cmd_;
vertex_type vertex_;
private:
void advance ()
{
if (pos_ < cont_->size())
{
value_type x,y;
vertex_.cmd=cont_->get_vertex(pos_,&x,&y);
vertex_.x=Transform::apply(x);
vertex_.y=Transform::apply(y);
}
else
{
vertex_.cmd=SEG_END;
vertex_.x=0;
vertex_.y=0;
}
++pos_;
}
public:
path_iterator()
: cont_(0),
pos_(0),
cmd_(SEG_END),
vertex_(0,0,cmd_) {}
explicit path_iterator(const container_type& cont)
: cont_(&cont),
pos_(0),
cmd_(SEG_MOVETO),
vertex_(0,0,cmd_)
{
advance();
}
path_iterator& operator++()
{
advance();
return *this;
}
const vertex_type& operator*() const
{
return vertex_;
}
const vertex_type* operator->() const
{
return &vertex_;
}
bool operator !=(const path_iterator& itr)
{
return vertex_.cmd !=itr.vertex_.cmd;
}
};
template <typename Transform>
path_iterator<Transform> begin() const
{
return path_iterator<Transform>(cont_);
} }
template <typename Transform> void transform(mapnik::CoordTransform const& t)
path_iterator<Transform> end() const
{ {
return path_iterator<Transform>(); unsigned size = cont_.size();
} for (unsigned pos=0; pos < size; ++pos)
void transform(const mapnik::CoordTransform& t)
{
for (unsigned pos=0;pos<cont_.size();++pos)
{ {
cont_.transform_at(pos,t); cont_.transform_at(pos,t);
} }
} }
unsigned num_points() const unsigned num_points() const
{ {
return cont_.size(); return cont_.size();
} }
@ -176,69 +174,27 @@ namespace mapnik
itr_=0; itr_=0;
} }
virtual ~geometry() {}
private:
geometry(const geometry&);
geometry& operator=(const geometry&);
};
template <typename T, template <typename> class Container=vertex_vector>
class point : public geometry<T,Container>
{
typedef geometry<T,Container> geometry_base;
typedef typename geometry<T,Container>::value_type value_type;
using geometry<T,Container>::cont_;
public:
point(int srid)
: geometry<T,Container>(srid)
{}
int type() const
{
return Point;
}
bool hit_test(value_type x,value_type y) const bool hit_test(value_type x,value_type y) const
{ {
typedef typename geometry_base::template path_iterator<NO_SHIFT> path_iterator; return false;
path_iterator start = geometry_base::template begin<NO_SHIFT>();
path_iterator end = geometry_base::template end<NO_SHIFT>();
return point_on_points(x,y,start,end);
} }
virtual ~polygon() {}
}; };
template <typename T, template <typename> class Container=vertex_vector> template <typename T, template <typename> class Container=vertex_vector>
class polygon : public geometry<T,Container> class line_string : public geometry<T>
{ {
typedef geometry<T,Container> geometry_base; typedef geometry<T> geometry_base;
typedef typename geometry_base::value_type value_type; typedef typename geometry_base::value_type value_type;
typedef typename geometry<T>::vertex_type vertex_type;
public: typedef Container<vertex_type> container_type;
polygon(int srid) private:
: geometry_base(srid) container_type cont_;
{} mutable unsigned itr_;
int type() const
{
return Polygon;
}
bool hit_test(value_type x,value_type y) const
{
typedef typename geometry_base::template path_iterator<NO_SHIFT> path_iterator;
path_iterator start = geometry_base::template begin<NO_SHIFT>();
path_iterator end = geometry_base::template end<NO_SHIFT>();
return point_inside_path(x,y, start,end);
}
};
template <typename T, template <typename> class Container=vertex_vector>
class line_string : public geometry<T,Container>
{
typedef geometry<T,Container> geometry_base;
typedef typename geometry<T,Container>::value_type value_type;
public: public:
line_string(int srid) line_string(int srid)
: geometry<T,Container>(srid) : geometry_base(srid),
itr_(0)
{} {}
int type() const int type() const
@ -246,13 +202,45 @@ namespace mapnik
return LineString; return LineString;
} }
void line_to(value_type x,value_type y)
{
cont_.push_back(x,y,SEG_LINETO);
}
void move_to(value_type x,value_type y)
{
cont_.push_back(x,y,SEG_MOVETO);
}
void transform(mapnik::CoordTransform const& t)
{
unsigned size = cont_.size();
for (unsigned pos=0; pos < size; ++pos)
{
cont_.transform_at(pos,t);
}
}
unsigned num_points() const
{
return cont_.size();
}
unsigned vertex(double* x, double* y)
{
return cont_.get_vertex(itr_++,x,y);
}
void rewind(unsigned )
{
itr_=0;
}
bool hit_test(value_type x,value_type y) const bool hit_test(value_type x,value_type y) const
{ {
typedef typename geometry_base::template path_iterator<NO_SHIFT> path_iterator; return false;
path_iterator start = geometry_base::template begin<NO_SHIFT>();
path_iterator end = geometry_base::template end<NO_SHIFT>();
return point_on_path(x,y,start,end);
} }
virtual ~line_string() {}
}; };
typedef point<vertex2d> point_impl; typedef point<vertex2d> point_impl;