sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mapnik/include/mapnik/vertex_cache.hpp
Mathis Logemann e7c3d04309 format dir include and src 
format all files

Revert "format all files"

This reverts commit 95d5812e49e7f916b68e786596f5a8eb5bcac414.

Revert "format some files"

This reverts commit ed3c8762d4d828b2b28e7b18809fc33f4f8ccaf5.

format all files

fix formatting in dir include

fix formatting of debug macro
2022-01-27 00:12:08 +01:00

264 lines
8.6 KiB
C++
Raw Blame History

/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2021 Artem Pavlenko
*
* 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
*
*****************************************************************************/
#ifndef MAPNIK_VERTEX_CACHE_HPP
#define MAPNIK_VERTEX_CACHE_HPP
// mapnik
#include <mapnik/pixel_position.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/config.hpp>
#include <mapnik/util/noncopyable.hpp>
#include <mapnik/warning.hpp>
MAPNIK_DISABLE_WARNING_PUSH
#include <mapnik/warning_ignore_agg.hpp>
#include "agg_basics.h"
MAPNIK_DISABLE_WARNING_POP
// stl
#include <vector>
#include <memory>
#include <map>
namespace mapnik {
class vertex_cache;
using vertex_cache_ptr = std::unique_ptr<vertex_cache>;
// Caches all path points and their lengths. Allows easy moving in both directions.
class MAPNIK_DECL vertex_cache : util::noncopyable
{
struct segment
{
segment(double x, double y, double _length)
: pos(x, y)
, length(_length)
{}
pixel_position
pos; // Last point of this segment, first point is implicitly defined by the previous segement in this vector
double length;
};
// The first segment always has the length 0 and just defines the starting point.
struct segment_vector
{
segment_vector()
: vector()
, length(0.)
{}
void add_segment(double x, double y, double len)
{
if (len == 0. && !vector.empty())
return; // Don't add zero length segments
vector.emplace_back(x, y, len);
length += len;
}
using iterator = std::vector<segment>::iterator;
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.
class state
{
segment_vector::iterator current_segment;
double position_in_segment;
pixel_position current_position;
pixel_position segment_starting_point;
double position_;
friend class vertex_cache;
public:
pixel_position const& position() const { return current_position; }
};
class scoped_state : util::noncopyable
{
public:
scoped_state(vertex_cache& pp)
: pp_(pp)
, state_(pp.save_state())
, restored_(false)
{}
void restore()
{
pp_.restore_state(state_);
restored_ = true;
}
~scoped_state()
{
if (!restored_)
pp_.restore_state(state_);
}
state const& get_state() const { return state_; }
private:
vertex_cache& pp_;
state state_;
bool restored_;
};
///////////////////////////////////////////////////////////////////////
template<typename T>
vertex_cache(T& path);
vertex_cache(vertex_cache&& rhs);
double length() const { return current_subpath_->length; }
pixel_position const& current_position() const { return current_position_; }
double angle(double width = 0.);
double current_segment_angle();
double linear_position() const { return position_; }
// Returns a parallel line in the specified distance.
vertex_cache& get_offseted(double offset, double region_width);
// Skip a certain amount of space.
// This functions automatically calculate new points if the position is not exactly
// on a point on the path.
bool forward(double length);
// Go backwards.
bool backward(double length);
// Move in any direction (based on sign of length). Returns false if it reaches either end of the path.
bool move(double length);
// Move to given distance.
bool move_to_distance(double distance);
// Work on next subpath. Returns false if the is no next 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);
// Go back to initial state.
void reset();
// position on this line closest to the target position
double position_closest_to(pixel_position const& target_pos);
private:
void rewind_subpath();
bool next_segment();
bool previous_segment();
void find_line_circle_intersection(double cx,
double cy,
double radius,
double x1,
double y1,
double x2,
double y2,
double& ix,
double& iy) const;
// Position as calculated by last move/forward/next call.
pixel_position current_position_;
// First pixel of current segment.
pixel_position segment_starting_point_;
// List of all subpaths.
std::vector<segment_vector> subpaths_;
// Currently active subpath.
std::vector<segment_vector>::iterator current_subpath_;
// Current segment for normal operation (move()).
segment_vector::iterator current_segment_;
// Current segment in compatibility mode (vertex(), rewind()).
segment_vector::iterator vertex_segment_;
// Currently active subpath in compatibility mode.
std::vector<segment_vector>::iterator vertex_subpath_;
// State is initialized (after first call to next_subpath()).
bool initialized_;
// Position from start of segment.
double position_in_segment_;
// Angle for current segment.
mutable double angle_;
// Is the value in angle_ valid?
// Used to avoid unnecessary calculations.
mutable bool angle_valid_;
using offseted_lines_map = std::map<double, vertex_cache_ptr>;
// Cache of all offseted lines already computed.
offseted_lines_map offseted_lines_;
// Linear position, i.e distance from start of line.
double position_;
};
template<typename T>
vertex_cache::vertex_cache(T& path)
: current_position_()
, segment_starting_point_()
, subpaths_()
, current_subpath_()
, current_segment_()
, vertex_segment_()
, vertex_subpath_()
, initialized_(false)
, position_in_segment_(0.)
, angle_(0.)
, angle_valid_(false)
, offseted_lines_()
, position_(0.)
{
path.rewind(0);
unsigned cmd;
double new_x = 0., new_y = 0., old_x = 0., old_y = 0.;
bool first = true; // current_subpath_ uninitalized
while (!agg::is_stop(cmd = path.vertex(&new_x, &new_y)))
{
if (agg::is_move_to(cmd))
{
// Create new sub path
subpaths_.emplace_back();
current_subpath_ = subpaths_.end() - 1;
current_subpath_->add_segment(new_x, new_y, 0);
first = false;
}
else if (agg::is_line_to(cmd))
{
if (first)
{
MAPNIK_LOG_ERROR(vertex_cache) << "No starting point in path!\n";
continue;
}
double dx = old_x - new_x;
double dy = old_y - new_y;
double segment_length = std::sqrt(dx * dx + dy * dy);
current_subpath_->add_segment(new_x, new_y, segment_length);
}
else if (agg::is_closed(cmd) && !current_subpath_->vector.empty())
{
segment const& first_segment = current_subpath_->vector[0];
double dx = old_x - first_segment.pos.x;
double dy = old_y - first_segment.pos.y;
double segment_length = std::sqrt(dx * dx + dy * dy);
current_subpath_->add_segment(first_segment.pos.x, first_segment.pos.y, segment_length);
}
old_x = new_x;
old_y = new_y;
}
}
} // namespace mapnik
#endif
Reference in a new issue View git blame Copy permalink