mirror of
https://github.com/mapbox/tippecanoe.git
synced 2025-02-08 20:10:15 +00:00
646 lines
18 KiB
C++
646 lines
18 KiB
C++
#pragma once
|
|
|
|
#include <assert.h>
|
|
#include <cmath>
|
|
#include <deque>
|
|
#include <list>
|
|
#include <map>
|
|
#include <mapbox/geometry/box.hpp>
|
|
#include <mapbox/geometry/wagyu/point.hpp>
|
|
#include <set>
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
#ifdef DEBUG
|
|
#include <execinfo.h>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <stdio.h>
|
|
//
|
|
// void* callstack[128];
|
|
// int i, frames = backtrace(callstack, 128);
|
|
// char** strs = backtrace_symbols(callstack, frames);
|
|
// for (i = 0; i < frames; ++i) {
|
|
// printf("%s\n", strs[i]);
|
|
// }
|
|
// free(strs);
|
|
#endif
|
|
|
|
namespace mapbox {
|
|
namespace geometry {
|
|
namespace wagyu {
|
|
|
|
template <typename T>
|
|
double area_from_point(point_ptr<T> op, std::size_t& size, mapbox::geometry::box<T>& bbox) {
|
|
point_ptr<T> startOp = op;
|
|
size = 0;
|
|
double a = 0.0;
|
|
T min_x = op->x;
|
|
T max_x = op->x;
|
|
T min_y = op->y;
|
|
T max_y = op->y;
|
|
do {
|
|
++size;
|
|
if (op->x > max_x) {
|
|
max_x = op->x;
|
|
} else if (op->x < min_x) {
|
|
min_x = op->x;
|
|
}
|
|
if (op->y > max_y) {
|
|
max_y = op->y;
|
|
} else if (op->y < min_y) {
|
|
min_y = op->y;
|
|
}
|
|
a += static_cast<double>(op->prev->x + op->x) * static_cast<double>(op->prev->y - op->y);
|
|
op = op->next;
|
|
} while (op != startOp);
|
|
bbox.min.x = min_x;
|
|
bbox.max.x = max_x;
|
|
bbox.min.y = min_y;
|
|
bbox.max.y = max_y;
|
|
return a * 0.5;
|
|
}
|
|
|
|
// NOTE: ring and ring_ptr are forward declared in wagyu/point.hpp
|
|
|
|
template <typename T>
|
|
using ring_vector = std::vector<ring_ptr<T>>;
|
|
|
|
template <typename T>
|
|
struct ring {
|
|
std::size_t ring_index; // To support unset 0 is undefined and indexes offset by 1
|
|
|
|
std::size_t size_; // number of points in the ring
|
|
double area_; // area of the ring
|
|
mapbox::geometry::box<T> bbox; // bounding box of the ring
|
|
|
|
ring_ptr<T> parent;
|
|
ring_vector<T> children;
|
|
|
|
point_ptr<T> points;
|
|
point_ptr<T> bottom_point;
|
|
bool is_hole_;
|
|
bool corrected;
|
|
|
|
ring(ring const&) = delete;
|
|
ring& operator=(ring const&) = delete;
|
|
|
|
ring()
|
|
: ring_index(0),
|
|
size_(0),
|
|
area_(std::numeric_limits<double>::quiet_NaN()),
|
|
bbox({ 0, 0 }, { 0, 0 }),
|
|
parent(nullptr),
|
|
children(),
|
|
points(nullptr),
|
|
bottom_point(nullptr),
|
|
is_hole_(false),
|
|
corrected(false) {
|
|
}
|
|
|
|
void reset_stats() {
|
|
area_ = std::numeric_limits<double>::quiet_NaN();
|
|
is_hole_ = false;
|
|
bbox.min.x = 0;
|
|
bbox.min.y = 0;
|
|
bbox.max.x = 0;
|
|
bbox.max.y = 0;
|
|
size_ = 0;
|
|
}
|
|
|
|
void recalculate_stats() {
|
|
if (points != nullptr) {
|
|
area_ = area_from_point(points, size_, bbox);
|
|
is_hole_ = !(area_ > 0.0);
|
|
}
|
|
}
|
|
|
|
void set_stats(double a, std::size_t s, mapbox::geometry::box<T> const& b) {
|
|
bbox = b;
|
|
area_ = a;
|
|
size_ = s;
|
|
is_hole_ = !(area_ > 0.0);
|
|
}
|
|
|
|
double area() {
|
|
if (std::isnan(area_)) {
|
|
recalculate_stats();
|
|
}
|
|
return area_;
|
|
}
|
|
|
|
bool is_hole() {
|
|
if (std::isnan(area_)) {
|
|
recalculate_stats();
|
|
}
|
|
return is_hole_;
|
|
}
|
|
|
|
std::size_t size() {
|
|
if (std::isnan(area_)) {
|
|
recalculate_stats();
|
|
}
|
|
return size_;
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
using hot_pixel_vector = std::vector<mapbox::geometry::point<T>>;
|
|
|
|
template <typename T>
|
|
using hot_pixel_itr = typename hot_pixel_vector<T>::iterator;
|
|
|
|
template <typename T>
|
|
using hot_pixel_rev_itr = typename hot_pixel_vector<T>::reverse_iterator;
|
|
|
|
template <typename T>
|
|
struct ring_manager {
|
|
|
|
ring_vector<T> children;
|
|
point_vector<T> all_points;
|
|
hot_pixel_vector<T> hot_pixels;
|
|
hot_pixel_itr<T> current_hp_itr;
|
|
std::deque<point<T>> points;
|
|
std::deque<ring<T>> rings;
|
|
std::vector<point<T>> storage;
|
|
std::size_t index;
|
|
|
|
ring_manager(ring_manager const&) = delete;
|
|
ring_manager& operator=(ring_manager const&) = delete;
|
|
|
|
ring_manager()
|
|
: children(),
|
|
all_points(),
|
|
hot_pixels(),
|
|
current_hp_itr(hot_pixels.end()),
|
|
points(),
|
|
rings(),
|
|
storage(),
|
|
index(0) {
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
void preallocate_point_memory(ring_manager<T>& rings, std::size_t size) {
|
|
rings.storage.reserve(size);
|
|
rings.all_points.reserve(size);
|
|
}
|
|
|
|
template <typename T>
|
|
ring_ptr<T> create_new_ring(ring_manager<T>& manager) {
|
|
manager.rings.emplace_back();
|
|
ring_ptr<T> result = &manager.rings.back();
|
|
result->ring_index = manager.index++;
|
|
return result;
|
|
}
|
|
|
|
template <typename T>
|
|
point_ptr<T>
|
|
create_new_point(ring_ptr<T> r, mapbox::geometry::point<T> const& pt, ring_manager<T>& rings) {
|
|
point_ptr<T> point;
|
|
if (rings.storage.size() < rings.storage.capacity()) {
|
|
rings.storage.emplace_back(r, pt);
|
|
point = &rings.storage.back();
|
|
} else {
|
|
rings.points.emplace_back(r, pt);
|
|
point = &rings.points.back();
|
|
}
|
|
rings.all_points.push_back(point);
|
|
return point;
|
|
}
|
|
|
|
template <typename T>
|
|
point_ptr<T> create_new_point(ring_ptr<T> r,
|
|
mapbox::geometry::point<T> const& pt,
|
|
point_ptr<T> before_this_point,
|
|
ring_manager<T>& rings) {
|
|
point_ptr<T> point;
|
|
if (rings.storage.size() < rings.storage.capacity()) {
|
|
rings.storage.emplace_back(r, pt, before_this_point);
|
|
point = &rings.storage.back();
|
|
} else {
|
|
rings.points.emplace_back(r, pt, before_this_point);
|
|
point = &rings.points.back();
|
|
}
|
|
rings.all_points.push_back(point);
|
|
return point;
|
|
}
|
|
|
|
template <typename T>
|
|
void set_to_children(ring_ptr<T> r, ring_vector<T>& children) {
|
|
for (auto& c : children) {
|
|
if (c == nullptr) {
|
|
c = r;
|
|
return;
|
|
}
|
|
}
|
|
children.push_back(r);
|
|
}
|
|
|
|
template <typename T>
|
|
void remove_from_children(ring_ptr<T> r, ring_vector<T>& children) {
|
|
for (auto& c : children) {
|
|
if (c == r) {
|
|
c = nullptr;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void assign_as_child(ring_ptr<T> new_ring, ring_ptr<T> parent, ring_manager<T>& manager) {
|
|
// Assigning as a child assumes that this is
|
|
// a brand new ring. Therefore it does
|
|
// not have any existing relationships
|
|
if ((parent == nullptr && new_ring->is_hole()) ||
|
|
(parent != nullptr && new_ring->is_hole() == parent->is_hole())) {
|
|
throw std::runtime_error(
|
|
"Trying to assign a child that is the same orientation as the parent");
|
|
}
|
|
auto& children = parent == nullptr ? manager.children : parent->children;
|
|
set_to_children(new_ring, children);
|
|
new_ring->parent = parent;
|
|
}
|
|
|
|
template <typename T>
|
|
void reassign_as_child(ring_ptr<T> ring, ring_ptr<T> parent, ring_manager<T>& manager) {
|
|
// Reassigning a ring assumes it already
|
|
// has an existing parent
|
|
if ((parent == nullptr && ring->is_hole()) ||
|
|
(parent != nullptr && ring->is_hole() == parent->is_hole())) {
|
|
throw std::runtime_error(
|
|
"Trying to re-assign a child that is the same orientation as the parent");
|
|
}
|
|
|
|
// Remove the old child relationship
|
|
auto& old_children = ring->parent == nullptr ? manager.children : ring->parent->children;
|
|
remove_from_children(ring, old_children);
|
|
|
|
// Add new child relationship
|
|
auto& children = parent == nullptr ? manager.children : parent->children;
|
|
set_to_children(ring, children);
|
|
ring->parent = parent;
|
|
}
|
|
|
|
template <typename T>
|
|
void assign_as_sibling(ring_ptr<T> new_ring, ring_ptr<T> sibling, ring_manager<T>& manager) {
|
|
// Assigning as a sibling assumes that this is
|
|
// a brand new ring. Therefore it does
|
|
// not have any existing relationships
|
|
if (new_ring->is_hole() != sibling->is_hole()) {
|
|
throw std::runtime_error(
|
|
"Trying to assign to be a sibling that is not the same orientation as the sibling");
|
|
}
|
|
auto& children = sibling->parent == nullptr ? manager.children : sibling->parent->children;
|
|
set_to_children(new_ring, children);
|
|
new_ring->parent = sibling->parent;
|
|
}
|
|
|
|
template <typename T>
|
|
void reassign_as_sibling(ring_ptr<T> ring, ring_ptr<T> sibling, ring_manager<T>& manager) {
|
|
if (ring->parent == sibling->parent) {
|
|
return;
|
|
}
|
|
// Assigning as a sibling assumes that this is
|
|
// a brand new ring. Therefore it does
|
|
// not have any existing relationships
|
|
if (ring->is_hole() != sibling->is_hole()) {
|
|
throw std::runtime_error(
|
|
"Trying to assign to be a sibling that is not the same orientation as the sibling");
|
|
}
|
|
// Remove the old child relationship
|
|
auto& old_children = ring->parent == nullptr ? manager.children : ring->parent->children;
|
|
remove_from_children(ring, old_children);
|
|
// Add new relationship
|
|
auto& children = sibling->parent == nullptr ? manager.children : sibling->parent->children;
|
|
set_to_children(ring, children);
|
|
ring->parent = sibling->parent;
|
|
}
|
|
|
|
template <typename T>
|
|
void ring1_replaces_ring2(ring_ptr<T> ring1, ring_ptr<T> ring2, ring_manager<T>& manager) {
|
|
assert(ring1 != ring2);
|
|
auto& ring1_children = ring1 == nullptr ? manager.children : ring1->children;
|
|
for (auto& c : ring2->children) {
|
|
if (c == nullptr) {
|
|
continue;
|
|
}
|
|
c->parent = ring1;
|
|
set_to_children(c, ring1_children);
|
|
c = nullptr;
|
|
}
|
|
// Remove the old child relationship
|
|
auto& old_children = ring2->parent == nullptr ? manager.children : ring2->parent->children;
|
|
remove_from_children(ring2, old_children);
|
|
ring2->points = nullptr;
|
|
ring2->reset_stats();
|
|
}
|
|
|
|
template <typename T>
|
|
void remove_points(point_ptr<T> pt) {
|
|
if (pt != nullptr) {
|
|
pt->prev->next = nullptr;
|
|
while (pt != nullptr) {
|
|
point_ptr<T> tmp = pt;
|
|
pt = pt->next;
|
|
tmp->next = nullptr;
|
|
tmp->prev = nullptr;
|
|
tmp->ring = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void remove_ring_and_points(ring_ptr<T> r,
|
|
ring_manager<T>& manager,
|
|
bool remove_children = true,
|
|
bool remove_from_parent = true) {
|
|
// Removes a ring and any children that might be
|
|
// under that ring.
|
|
for (auto& c : r->children) {
|
|
if (c == nullptr) {
|
|
continue;
|
|
}
|
|
if (remove_children) {
|
|
remove_ring_and_points(c, manager, true, false);
|
|
}
|
|
c = nullptr;
|
|
}
|
|
if (remove_from_parent) {
|
|
// Remove the old child relationship
|
|
auto& old_children = r->parent == nullptr ? manager.children : r->parent->children;
|
|
remove_from_children(r, old_children);
|
|
}
|
|
point_ptr<T> pt = r->points;
|
|
if (pt != nullptr) {
|
|
pt->prev->next = nullptr;
|
|
while (pt != nullptr) {
|
|
point_ptr<T> tmp = pt;
|
|
pt = pt->next;
|
|
tmp->next = nullptr;
|
|
tmp->prev = nullptr;
|
|
tmp->ring = nullptr;
|
|
}
|
|
}
|
|
r->points = nullptr;
|
|
r->reset_stats();
|
|
}
|
|
|
|
template <typename T>
|
|
void remove_ring(ring_ptr<T> r,
|
|
ring_manager<T>& manager,
|
|
bool remove_children = true,
|
|
bool remove_from_parent = true) {
|
|
// Removes a ring and any children that might be
|
|
// under that ring.
|
|
for (auto& c : r->children) {
|
|
if (c == nullptr) {
|
|
continue;
|
|
}
|
|
if (remove_children) {
|
|
remove_ring(c, manager, true, false);
|
|
}
|
|
c = nullptr;
|
|
}
|
|
if (remove_from_parent) {
|
|
// Remove the old child relationship
|
|
auto& old_children = r->parent == nullptr ? manager.children : r->parent->children;
|
|
remove_from_children(r, old_children);
|
|
}
|
|
r->points = nullptr;
|
|
r->reset_stats();
|
|
}
|
|
|
|
template <typename T>
|
|
inline std::size_t ring_depth(ring_ptr<T> r) {
|
|
std::size_t depth = 0;
|
|
if (!r) {
|
|
return depth;
|
|
}
|
|
while (r->parent) {
|
|
depth++;
|
|
r = r->parent;
|
|
}
|
|
return depth;
|
|
}
|
|
|
|
template <typename T>
|
|
inline bool ring_is_hole(ring_ptr<T> r) {
|
|
// This is different then the "normal" way of determing if
|
|
// a ring is a hole or not because it uses the depth of the
|
|
// the ring to determine if it is a hole or not. This is only done
|
|
// intially when rings are output from Vatti.
|
|
return ring_depth(r) & 1;
|
|
}
|
|
|
|
template <typename T>
|
|
void set_next(const_point_ptr<T>& node, const const_point_ptr<T>& next_node) {
|
|
node->next = next_node;
|
|
}
|
|
|
|
template <typename T>
|
|
point_ptr<T> get_next(const_point_ptr<T>& node) {
|
|
return node->next;
|
|
}
|
|
|
|
template <typename T>
|
|
point_ptr<T> get_prev(const_point_ptr<T>& node) {
|
|
return node->prev;
|
|
}
|
|
|
|
template <typename T>
|
|
void set_prev(const_point_ptr<T>& node, const const_point_ptr<T>& prev_node) {
|
|
node->prev = prev_node;
|
|
}
|
|
|
|
template <typename T>
|
|
void init(const_point_ptr<T>& node) {
|
|
set_next(node, node);
|
|
set_prev(node, node);
|
|
}
|
|
|
|
template <typename T>
|
|
void link_before(point_ptr<T>& node, point_ptr<T>& new_node) {
|
|
point_ptr<T> prev_node = get_prev(node);
|
|
set_prev(new_node, prev_node);
|
|
set_next(new_node, node);
|
|
set_prev(node, new_node);
|
|
set_next(prev_node, new_node);
|
|
}
|
|
|
|
template <typename T>
|
|
void link_after(point_ptr<T>& node, point_ptr<T>& new_node) {
|
|
point_ptr<T> next_node = get_next(node);
|
|
set_prev(new_node, node);
|
|
set_next(new_node, next_node);
|
|
set_next(node, new_node);
|
|
set_prev(next_node, new_node);
|
|
}
|
|
|
|
template <typename T>
|
|
void transfer_point(point_ptr<T>& p, point_ptr<T>& b, point_ptr<T>& e) {
|
|
if (b != e) {
|
|
point_ptr<T> prev_p = get_prev(p);
|
|
point_ptr<T> prev_b = get_prev(b);
|
|
point_ptr<T> prev_e = get_prev(e);
|
|
set_next(prev_e, p);
|
|
set_prev(p, prev_e);
|
|
set_next(prev_b, e);
|
|
set_prev(e, prev_b);
|
|
set_next(prev_p, b);
|
|
set_prev(b, prev_p);
|
|
} else {
|
|
link_before(p, b);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void reverse_ring(point_ptr<T> pp) {
|
|
if (!pp) {
|
|
return;
|
|
}
|
|
point_ptr<T> pp1;
|
|
point_ptr<T> pp2;
|
|
pp1 = pp;
|
|
do {
|
|
pp2 = pp1->next;
|
|
pp1->next = pp1->prev;
|
|
pp1->prev = pp2;
|
|
pp1 = pp2;
|
|
} while (pp1 != pp);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
|
|
template <class charT, class traits, typename T>
|
|
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
|
|
ring<T>& r) {
|
|
out << " ring_index: " << r.ring_index << std::endl;
|
|
if (!r.parent) {
|
|
// out << " parent_ring ptr: nullptr" << std::endl;
|
|
out << " parent_index: -----" << std::endl;
|
|
} else {
|
|
// out << " parent_ring ptr: " << r.parent << std::endl;
|
|
out << " parent_ring idx: " << r.parent->ring_index << std::endl;
|
|
}
|
|
ring_ptr<T> n = const_cast<ring_ptr<T>>(&r);
|
|
if (ring_is_hole(n)) {
|
|
out << " is_hole: true " << std::endl;
|
|
} else {
|
|
out << " is_hole: false " << std::endl;
|
|
}
|
|
auto pt_itr = r.points;
|
|
if (pt_itr) {
|
|
out << " area: " << r.area() << std::endl;
|
|
out << " points:" << std::endl;
|
|
out << " [[[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
while (pt_itr != r.points) {
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
}
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "]]]" << std::endl;
|
|
} else {
|
|
out << " area: NONE" << std::endl;
|
|
out << " points: NONE" << std::endl;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
template <typename T>
|
|
std::string debug_ring_addresses(ring_ptr<T> r) {
|
|
std::ostringstream out;
|
|
out << "Ring: " << r->ring_index << std::endl;
|
|
if (r->points == nullptr) {
|
|
out << " Ring has no points" << std::endl;
|
|
return out.str();
|
|
}
|
|
auto pt_itr = r->points;
|
|
do {
|
|
out << " [" << pt_itr->x << "," << pt_itr->y << "] - " << pt_itr << std::endl;
|
|
pt_itr = pt_itr->next;
|
|
} while (pt_itr != r->points);
|
|
return out.str();
|
|
}
|
|
|
|
template <typename T>
|
|
std::string output_as_polygon(ring_ptr<T> r) {
|
|
std::ostringstream out;
|
|
|
|
auto pt_itr = r->points;
|
|
if (pt_itr) {
|
|
out << "[";
|
|
out << "[[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
while (pt_itr != r->points) {
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
}
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "]]";
|
|
for (auto const& c : r->children) {
|
|
if (c == nullptr) {
|
|
continue;
|
|
}
|
|
pt_itr = c->points;
|
|
if (pt_itr) {
|
|
out << ",[[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
while (pt_itr != c->points) {
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
|
|
pt_itr = pt_itr->next;
|
|
}
|
|
out << "[" << pt_itr->x << "," << pt_itr->y << "]]";
|
|
}
|
|
}
|
|
out << "]" << std::endl;
|
|
} else {
|
|
out << "[]" << std::endl;
|
|
}
|
|
|
|
return out.str();
|
|
}
|
|
|
|
template <class charT, class traits, typename T>
|
|
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
|
|
ring_vector<T>& rings) {
|
|
out << "START RING VECTOR" << std::endl;
|
|
for (auto& r : rings) {
|
|
if (r == nullptr || !r->points) {
|
|
continue;
|
|
}
|
|
out << " ring: " << r->ring_index << " - " << r << std::endl;
|
|
out << *r;
|
|
}
|
|
out << "END RING VECTOR" << std::endl;
|
|
return out;
|
|
}
|
|
|
|
template <class charT, class traits, typename T>
|
|
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
|
|
std::deque<ring<T>>& rings) {
|
|
out << "START RING VECTOR" << std::endl;
|
|
for (auto& r : rings) {
|
|
if (!r.points) {
|
|
continue;
|
|
}
|
|
out << " ring: " << r.ring_index << std::endl;
|
|
out << r;
|
|
}
|
|
out << "END RING VECTOR" << std::endl;
|
|
return out;
|
|
}
|
|
|
|
template <class charT, class traits, typename T>
|
|
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
|
|
hot_pixel_vector<T>& hp_vec) {
|
|
out << "Hot Pixels: " << std::endl;
|
|
for (auto& hp : hp_vec) {
|
|
out << hp << std::endl;
|
|
}
|
|
return out;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|