699 lines
21 KiB
C++
699 lines
21 KiB
C++
/*****************************************************************************
|
|
*
|
|
* This file is part of Mapnik (c++ mapping toolkit)
|
|
*
|
|
* Copyright (C) 2006 Artem Pavlenko
|
|
* Copyright (C) 2006 10East Corp.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*****************************************************************************/
|
|
|
|
//$Id$
|
|
|
|
//stl
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// boost
|
|
#include <boost/shared_ptr.hpp>
|
|
#include <boost/utility.hpp>
|
|
#include <boost/ptr_container/ptr_vector.hpp>
|
|
#include <boost/thread/mutex.hpp>
|
|
#include <boost/tuple/tuple.hpp>
|
|
|
|
//mapnik
|
|
#include <mapnik/geometry.hpp>
|
|
#include <mapnik/placement_finder.hpp>
|
|
#include <mapnik/text_path.hpp>
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
namespace mapnik
|
|
{
|
|
//For shields
|
|
placement::placement(string_info *info_,
|
|
CoordTransform *ctrans_,
|
|
const proj_transform *proj_trans_,
|
|
geometry_ptr geom_,
|
|
std::pair<double, double> dimensions_)
|
|
: info(info_),
|
|
ctrans(ctrans_),
|
|
proj_trans(proj_trans_),
|
|
geom(geom_),
|
|
displacement_(0,0),
|
|
label_placement(point_placement),
|
|
dimensions(dimensions_),
|
|
has_dimensions(true),
|
|
shape_path(*ctrans_, *geom_, *proj_trans_),
|
|
total_distance_(-1.0),
|
|
wrap_width(0),
|
|
text_ratio(0),
|
|
label_spacing(0),
|
|
label_position_tolerance(0),
|
|
force_odd_labels(false),
|
|
max_char_angle_delta(0.0), avoid_edges(false)
|
|
{
|
|
}
|
|
|
|
//For text
|
|
placement::placement(string_info *info_,
|
|
CoordTransform *ctrans_,
|
|
const proj_transform *proj_trans_,
|
|
geometry_ptr geom_,
|
|
position const& displacement,
|
|
label_placement_e placement_)
|
|
: info(info_),
|
|
ctrans(ctrans_),
|
|
proj_trans(proj_trans_),
|
|
geom(geom_),
|
|
displacement_(displacement),
|
|
label_placement(placement_),
|
|
has_dimensions(false),
|
|
shape_path(*ctrans_, *geom_, *proj_trans_),
|
|
total_distance_(-1.0),
|
|
wrap_width(0),
|
|
text_ratio(0),
|
|
label_spacing(0),
|
|
label_position_tolerance(0),
|
|
force_odd_labels(false),
|
|
max_char_angle_delta(0.0),
|
|
avoid_edges(false)
|
|
{
|
|
}
|
|
|
|
placement::~placement()
|
|
{
|
|
}
|
|
|
|
unsigned placement::path_size() const
|
|
{
|
|
return geom->num_points();
|
|
}
|
|
|
|
std::pair<double, double> placement::get_position_at_distance(double target_distance)
|
|
{
|
|
double old_x, old_y, new_x, new_y;
|
|
double x, y;
|
|
x = y = 0.0;
|
|
|
|
double distance = 0.0;
|
|
|
|
shape_path.rewind(0);
|
|
shape_path.vertex(&new_x,&new_y);
|
|
unsigned num_points = geom->num_points();
|
|
for (unsigned i = 1; i < num_points; ++i)
|
|
{
|
|
double dx, dy;
|
|
|
|
old_x = new_x;
|
|
old_y = new_y;
|
|
|
|
shape_path.vertex(&new_x,&new_y);
|
|
|
|
dx = new_x - old_x;
|
|
dy = new_y - old_y;
|
|
|
|
double segment_length = sqrt(dx*dx + dy*dy);
|
|
|
|
distance += segment_length;
|
|
if (distance > target_distance)
|
|
{
|
|
x = new_x - dx*(distance - target_distance)/segment_length;
|
|
y = new_y - dy*(distance - target_distance)/segment_length;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return std::pair<double, double>(x, y);
|
|
}
|
|
|
|
double placement::get_total_distance()
|
|
{
|
|
if (total_distance_ < 0.0)
|
|
{
|
|
double old_x, old_y, new_x, new_y;
|
|
|
|
shape_path.rewind(0);
|
|
|
|
shape_path.vertex(&old_x,&old_y);
|
|
|
|
total_distance_ = 0.0;
|
|
|
|
unsigned num_points = geom->num_points();
|
|
for (unsigned i = 1; i < num_points ; ++i)
|
|
{
|
|
double dx, dy;
|
|
shape_path.vertex(&new_x,&new_y);
|
|
|
|
dx = new_x - old_x;
|
|
dy = new_y - old_y;
|
|
|
|
total_distance_ += sqrt(dx*dx + dy*dy);
|
|
|
|
old_x = new_x;
|
|
old_y = new_y;
|
|
}
|
|
}
|
|
|
|
return total_distance_;
|
|
}
|
|
|
|
void placement::clear_envelopes()
|
|
{
|
|
while (!envelopes.empty())
|
|
envelopes.pop();
|
|
}
|
|
|
|
|
|
template <typename DetectorT>
|
|
placement_finder<DetectorT>::placement_finder(DetectorT & detector,Envelope<double> const& e)
|
|
: detector_(detector),
|
|
dimensions_(e)
|
|
//detector_(Envelope<double>(e.minx() - buffer, e.miny() - buffer, e.maxx() + buffer, e.maxy() + buffer))
|
|
{
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
bool placement_finder<DetectorT>::find_placements(placement *p)
|
|
{
|
|
if (p->label_placement == point_placement)
|
|
{
|
|
return find_placement_horizontal(p);
|
|
}
|
|
else if (p->label_placement == line_placement)
|
|
{
|
|
return find_placement_follow(p);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
bool placement_finder<DetectorT>::find_placement_follow(placement *p)
|
|
{
|
|
std::pair<double, double> string_dimensions = p->info->get_dimensions();
|
|
double string_width = string_dimensions.first;
|
|
|
|
double distance = p->get_total_distance();
|
|
|
|
if (string_width > distance)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int num_labels = 0;
|
|
if (p->label_spacing)
|
|
num_labels = static_cast<int> (floor(distance / (p->label_spacing + string_width)));
|
|
if (p->force_odd_labels && num_labels%2 == 0)
|
|
num_labels--;
|
|
if (num_labels <= 0)
|
|
num_labels = 1;
|
|
|
|
double ideal_spacing = distance/num_labels;
|
|
std::vector<double> ideal_label_distances;
|
|
|
|
double middle = (distance / 2.0) - (string_width/2.0); //try draw text centered
|
|
|
|
if (num_labels % 2) //odd amount of labels
|
|
{
|
|
for (int a = 0; a < (num_labels+1)/2; a++)
|
|
{
|
|
ideal_label_distances.push_back(middle - (a*ideal_spacing));
|
|
|
|
if (a != 0)
|
|
ideal_label_distances.push_back(middle + (a*ideal_spacing));
|
|
}
|
|
}
|
|
else //even amount of labels
|
|
{
|
|
for (int a = 0; a < num_labels/2; a++)
|
|
{
|
|
ideal_label_distances.push_back(middle - (ideal_spacing/2.0) - (a*ideal_spacing));
|
|
ideal_label_distances.push_back(middle + (ideal_spacing/2.0) + (a*ideal_spacing));
|
|
}
|
|
}
|
|
|
|
double delta;
|
|
double tolerance;
|
|
|
|
if (p->label_position_tolerance > 0)
|
|
{
|
|
tolerance = p->label_position_tolerance;
|
|
delta = std::max ( 1.0, p->label_position_tolerance/100.0);
|
|
}
|
|
else
|
|
{
|
|
tolerance = ideal_spacing/2.0;
|
|
delta = ideal_spacing/100.0;
|
|
}
|
|
|
|
|
|
bool FoundPlacement = false;
|
|
std::vector<double>::const_iterator itr = ideal_label_distances.begin();
|
|
std::vector<double>::const_iterator end = ideal_label_distances.end();
|
|
for (; itr != end; ++itr)
|
|
{
|
|
//std::clog << "Trying to find txt placement at distance: " << *itr << std::endl;
|
|
for (double i = 0; i < tolerance; i += delta)
|
|
{
|
|
if (*itr + i > distance || *itr -i < 0.0)
|
|
continue;
|
|
|
|
p->clear_envelopes();
|
|
|
|
// check position +- delta for valid placement
|
|
if ( build_path_follow(p, *itr + i) ) {
|
|
update_detector(p);
|
|
FoundPlacement = true;
|
|
break;
|
|
}
|
|
|
|
p->clear_envelopes();
|
|
if ( build_path_follow(p, *itr - i) ) {
|
|
update_detector(p);
|
|
FoundPlacement = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if (FoundPlacement)
|
|
// std::clog << "Found Placement" << string_width << " " << distance << std::endl;
|
|
|
|
return FoundPlacement;
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
bool placement_finder<DetectorT>::find_placement_horizontal(placement *p)
|
|
{
|
|
if (p->path_size() == 1) // point geometry
|
|
{
|
|
if ( build_path_horizontal(p, 0) )
|
|
{
|
|
update_detector(p);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
double distance = p->get_total_distance();
|
|
//~ double delta = string_width/distance;
|
|
double delta = distance/100.0;
|
|
|
|
for (double i = 0; i < distance/2.0; i += delta)
|
|
{
|
|
p->clear_envelopes();
|
|
|
|
if ( build_path_horizontal(p, distance/2.0 + i) ) {
|
|
update_detector(p);
|
|
return true;
|
|
}
|
|
|
|
p->clear_envelopes();
|
|
|
|
if ( build_path_horizontal(p, distance/2.0 - i) ) {
|
|
update_detector(p);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
void placement_finder<DetectorT>::update_detector(placement *p)
|
|
{
|
|
while (!p->envelopes.empty())
|
|
{
|
|
Envelope<double> e = p->envelopes.front();
|
|
|
|
detector_.insert(e);
|
|
|
|
p->envelopes.pop();
|
|
}
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
bool placement_finder<DetectorT>::build_path_follow(placement *p, double target_distance)
|
|
{
|
|
double new_x, new_y, old_x, old_y;
|
|
unsigned cur_node = 0;
|
|
double next_char_x = 0;
|
|
double next_char_y = 0;
|
|
|
|
double angle = 0.0;
|
|
int orientation = 0;
|
|
|
|
p->current_placement.path.clear();
|
|
|
|
double x, y;
|
|
x = y = 0.0;
|
|
|
|
double distance = 0.0;
|
|
|
|
std::pair<double, double> string_dimensions = p->info->get_dimensions();
|
|
// double string_width = string_dimensions.first;
|
|
double string_height = string_dimensions.second;
|
|
|
|
// find the segment that our text should start on
|
|
p->shape_path.rewind(0);
|
|
p->shape_path.vertex(&new_x,&new_y);
|
|
old_x = new_x;
|
|
old_y = new_y;
|
|
unsigned num_points = p->geom->num_points();
|
|
for (unsigned i = 1; i < num_points; ++i)
|
|
{
|
|
double dx, dy;
|
|
|
|
cur_node++;
|
|
|
|
old_x = new_x;
|
|
old_y = new_y;
|
|
|
|
p->shape_path.vertex(&new_x,&new_y);
|
|
|
|
dx = new_x - old_x;
|
|
dy = new_y - old_y;
|
|
|
|
double segment_length = sqrt(dx*dx + dy*dy);
|
|
|
|
distance += segment_length;
|
|
if (distance > target_distance)
|
|
{
|
|
// this segment is greater that the target starting distance so start here
|
|
p->current_placement.starting_x = new_x - dx*(distance - target_distance)/segment_length;
|
|
p->current_placement.starting_y = new_y - dy*(distance - target_distance)/segment_length;
|
|
|
|
// angle text starts at and orientation
|
|
angle = atan2(-dy, dx);
|
|
orientation = fabs(angle) > M_PI/2 ? -1 : 1;
|
|
|
|
distance -= target_distance;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// now find the placement of each character starting from our initial segment
|
|
// determined above
|
|
double last_angle = angle;
|
|
for (unsigned i = 0; i < p->info->num_characters(); i++)
|
|
{
|
|
character_info ci;
|
|
unsigned c;
|
|
|
|
// grab the next character according to the orientation
|
|
ci = orientation > 0 ? p->info->at(i) : p->info->at(p->info->num_characters() - i - 1);
|
|
c = ci.character;
|
|
|
|
double angle_delta = 0;
|
|
|
|
// if the distance remaining in this segment is less than the character width
|
|
// move to the next segment
|
|
if (distance <= ci.width)
|
|
{
|
|
last_angle = angle;
|
|
while (distance <= ci.width)
|
|
{
|
|
double dx, dy;
|
|
|
|
cur_node++;
|
|
|
|
if (cur_node >= p->geom->num_points()) {
|
|
return false;
|
|
}
|
|
|
|
old_x = new_x;
|
|
old_y = new_y;
|
|
|
|
p->shape_path.vertex(&new_x,&new_y);
|
|
|
|
dx = new_x - old_x;
|
|
dy = new_y - old_y;
|
|
|
|
angle = atan2(-dy, dx );
|
|
distance += sqrt(dx*dx+dy*dy);
|
|
}
|
|
// since our rendering angle has changed then check against our
|
|
// max allowable angle change.
|
|
angle_delta = last_angle - angle;
|
|
// normalise between -180 and 180
|
|
while (angle_delta > M_PI)
|
|
angle_delta -= 2*M_PI;
|
|
while (angle_delta < -M_PI)
|
|
angle_delta += 2*M_PI;
|
|
if (p->max_char_angle_delta > 0 && fabs(angle_delta) > p->max_char_angle_delta*(M_PI/180))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
Envelope<double> e;
|
|
if (p->has_dimensions)
|
|
{
|
|
e.init(x, y, x + p->dimensions.first, y + p->dimensions.second);
|
|
}
|
|
|
|
|
|
double render_angle = angle;
|
|
|
|
x = new_x - (distance)*cos(angle);
|
|
y = new_y + (distance)*sin(angle);
|
|
//Center the text on the line.
|
|
x -= (((double)string_height/2.0) - 1.0)*cos(render_angle+M_PI/2);
|
|
y += (((double)string_height/2.0) - 1.0)*sin(render_angle+M_PI/2);
|
|
distance -= ci.width;
|
|
next_char_x = ci.width*cos(render_angle);
|
|
next_char_y = ci.width*sin(render_angle);
|
|
|
|
double render_x = x;
|
|
double render_y = y;
|
|
|
|
if (!p->has_dimensions)
|
|
{
|
|
// put four corners of the letter into envelope
|
|
e.init(render_x, render_y, render_x + ci.width*cos(render_angle), render_y - ci.width*sin(render_angle));
|
|
e.expand_to_include(render_x - ci.height*sin(render_angle), render_y - ci.height*cos(render_angle));
|
|
e.expand_to_include(render_x + (ci.width*cos(render_angle) - ci.height*sin(render_angle)), render_y - (ci.width*sin(render_angle) + ci.height*cos(render_angle)));
|
|
}
|
|
|
|
if (!detector_.has_placement(e))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (p->avoid_edges && !dimensions_.contains(e))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
p->envelopes.push(e);
|
|
|
|
if (orientation < 0)
|
|
{
|
|
// rotate in place
|
|
render_x += ci.width*cos(render_angle) - (string_height-2)*sin(render_angle);
|
|
render_y -= ci.width*sin(render_angle) + (string_height-2)*cos(render_angle);
|
|
render_angle += M_PI;
|
|
}
|
|
|
|
|
|
p->current_placement.path.add_node(c,render_x - p->current_placement.starting_x,
|
|
-render_y + p->current_placement.starting_y,
|
|
render_angle);
|
|
x += next_char_x;
|
|
y -= next_char_y;
|
|
}
|
|
p->placements.push_back(p->current_placement);
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
bool placement_finder<DetectorT>::build_path_horizontal(placement *p, double target_distance)
|
|
{
|
|
double x, y;
|
|
|
|
p->current_placement.path.clear();
|
|
|
|
std::pair<double, double> string_dimensions = p->info->get_dimensions();
|
|
double string_width = string_dimensions.first;
|
|
double string_height = string_dimensions.second;
|
|
|
|
// check if we need to wrap the string
|
|
double wrap_at = string_width + 1;
|
|
if (p->wrap_width && string_width > p->wrap_width)
|
|
{
|
|
if (p->text_ratio)
|
|
for (int i = 1; ((wrap_at = string_width/i)/(string_height*i)) > p->text_ratio && (string_width/i) > p->wrap_width; ++i);
|
|
else
|
|
wrap_at = p->wrap_width;
|
|
}
|
|
|
|
// work out where our line breaks need to be
|
|
std::vector<int> line_breaks;
|
|
std::vector<double> line_widths;
|
|
if (wrap_at < string_width && p->info->num_characters() > 0)
|
|
{
|
|
int line_count=0;
|
|
int last_space = 0;
|
|
string_width = 0;
|
|
string_height = 0;
|
|
double line_width = 0;
|
|
double line_height = 0;
|
|
double word_width = 0;
|
|
double word_height = 0;
|
|
for (unsigned int ii = 0; ii < p->info->num_characters(); ii++)
|
|
{
|
|
character_info ci;;
|
|
ci = p->info->at(ii);
|
|
|
|
unsigned c = ci.character;
|
|
word_width += ci.width;
|
|
word_height = word_height > ci.height ? word_height : ci.height;
|
|
++line_count;
|
|
|
|
if (c == ' ')
|
|
{
|
|
last_space = ii;
|
|
line_width += word_width;
|
|
line_height = line_height > word_height ? line_height : word_height;
|
|
word_width = 0;
|
|
word_height = 0;
|
|
}
|
|
if (line_width > 0 && line_width > wrap_at)
|
|
{
|
|
string_width = string_width > line_width ? string_width : line_width;
|
|
string_height += line_height;
|
|
line_breaks.push_back(last_space);
|
|
line_widths.push_back(line_width);
|
|
ii = last_space;
|
|
line_count = 0;
|
|
line_width = 0;
|
|
line_height = 0;
|
|
word_width = 0;
|
|
word_height = 0;
|
|
}
|
|
}
|
|
line_width += word_width;
|
|
string_width = string_width > line_width ? string_width : line_width;
|
|
line_breaks.push_back(p->info->num_characters() + 1);
|
|
line_widths.push_back(line_width);
|
|
}
|
|
if (line_breaks.size() == 0)
|
|
{
|
|
line_breaks.push_back(p->info->num_characters() + 1);
|
|
line_widths.push_back(string_width);
|
|
}
|
|
|
|
p->info->set_dimensions(string_width, string_height);
|
|
|
|
if (p->geom->type() == LineString)
|
|
{
|
|
std::pair<double, double> starting_pos = p->get_position_at_distance(target_distance);
|
|
|
|
p->current_placement.starting_x = starting_pos.first;
|
|
p->current_placement.starting_y = starting_pos.second;
|
|
}
|
|
else
|
|
{
|
|
p->geom->label_position(&p->current_placement.starting_x, &p->current_placement.starting_y);
|
|
// TODO:
|
|
// We would only want label position in final 'paper' coords.
|
|
// Move view and proj transforms to e.g. label_position(x,y,proj_trans,ctrans)?
|
|
double z=0;
|
|
p->proj_trans->backward(p->current_placement.starting_x, p->current_placement.starting_y, z);
|
|
p->ctrans->forward(&p->current_placement.starting_x, &p->current_placement.starting_y);
|
|
// apply displacement ( in pixels )
|
|
p->current_placement.starting_x += boost::tuples::get<0>(p->displacement_);
|
|
p->current_placement.starting_y += boost::tuples::get<1>(p->displacement_);
|
|
}
|
|
|
|
double line_height = 0;
|
|
unsigned int line_number = 0;
|
|
unsigned int index_to_wrap_at = line_breaks[line_number];
|
|
double line_width = line_widths[line_number];
|
|
|
|
x = -line_width/2.0;
|
|
y = -string_height/2.0 + 1.0;
|
|
|
|
for (unsigned i = 0; i < p->info->num_characters(); i++)
|
|
{
|
|
character_info ci;;
|
|
ci = p->info->at(i);
|
|
|
|
unsigned c = ci.character;
|
|
if (i == index_to_wrap_at)
|
|
{
|
|
index_to_wrap_at = line_breaks[++line_number];
|
|
line_width = line_widths[line_number];
|
|
y -= line_height;
|
|
x = -line_width/2.0;
|
|
line_height = 0;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
p->current_placement.path.add_node(c, x, y, 0.0);
|
|
|
|
Envelope<double> e;
|
|
if (p->has_dimensions)
|
|
{
|
|
e.init(p->current_placement.starting_x - (p->dimensions.first/2.0),
|
|
p->current_placement.starting_y - (p->dimensions.second/2.0),
|
|
p->current_placement.starting_x + (p->dimensions.first/2.0),
|
|
p->current_placement.starting_y + (p->dimensions.second/2.0));
|
|
}
|
|
else
|
|
{
|
|
e.init(p->current_placement.starting_x + x,
|
|
p->current_placement.starting_y - y,
|
|
p->current_placement.starting_x + x + ci.width,
|
|
p->current_placement.starting_y - y - ci.height);
|
|
}
|
|
|
|
if (!detector_.has_placement(e))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (p->avoid_edges && !dimensions_.contains(e))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
p->envelopes.push(e);
|
|
}
|
|
x += ci.width;
|
|
line_height = line_height > ci.height ? line_height : ci.height;
|
|
}
|
|
p->placements.push_back(p->current_placement);
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename DetectorT>
|
|
void placement_finder<DetectorT>::clear()
|
|
{
|
|
detector_.clear();
|
|
}
|
|
|
|
template class placement_finder<label_collision_detector3>;
|
|
|
|
} // namespace
|