529318615

Build Type

github

Committed by GitHub

Commit Message

Merge 4e523930c into 591322cbc

Pull Request Pull Request #527: Lazy render

Run Details

4904 of 8378 branches covered (58.53%)

Branch coverage included in aggregate %.

385 of 403 new or added lines in 6 files covered. (95.53%)

35 existing lines in 1 file now uncovered.

3328 of 3602 relevant lines covered (92.39%)

172201.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.24

/path_finding.cpp

#include <vector>
using std::vector;

#include <unordered_map>
using std::unordered_map;

#include <unordered_set>
using std::unordered_set;

#include <queue>
using std::priority_queue;

#include <utility>
using std::pair;
using std::make_pair;

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/astar_search.hpp>
#include <boost/optional.hpp>

#include "path_finding.hpp"
#include "options.hpp"
#include "geometry.hpp"
#include "bg_operators.hpp"
#include "bg_helpers.hpp"

namespace path_finding {

using boost::optional;
using boost::make_optional;

Neighbors::iterator Neighbors::iterator::operator++() {
  do {
    if (ring_index < 2) {
      ring_index++;
    } else {
      point_index++;
      while (ring_index-2 < neighbors->pfs->vertices().size() &&
             point_index >= neighbors->pfs->vertices()[ring_index-2].size()) {
        ring_index++;
        point_index = 0;
      }
    }
  } while (ring_index < neighbors->pfs->vertices().size()+2 &&
           !neighbors->is_neighbor(**this));
  return *this;
}

bool Neighbors::iterator::operator!=(const Neighbors::iterator& other) const {
  return ring_index != other.ring_index || point_index != other.point_index;
}

bool Neighbors::iterator::operator==(const Neighbors::iterator& other) const {
  return !(*this != other);
}

const point_type_fp& Neighbors::iterator::operator*() const {
  if (ring_index == 0) {
    return neighbors->start;
  } else if (ring_index == 1) {
    return neighbors->goal;
  } else {
    return neighbors->pfs->vertices()[ring_index-2][point_index];
  }
}

Neighbors::Neighbors(const point_type_fp& start, const point_type_fp& goal,
                     const point_type_fp& current,
                     const RingIndices& ring_indices,
                     coordinate_type_fp g_score_current,
                     const PathLimiter path_limiter,
                     const PathFindingSurface* pfs) :
    start(start),
    goal(goal),
    current(current),
    ring_indices(ring_indices),
    g_score_current(g_score_current),
    path_limiter(path_limiter),
    pfs(pfs) {}

// Returns a valid neighbor index that is either the one provided or
// the next higher valid one.
bool Neighbors::is_neighbor(const point_type_fp p) const {
  if (p == current) {
    return false;
  }
  if (path_limiter != nullptr && path_limiter(p, g_score_current + bg::distance(current, p))) {
    return false;
  }
  if (!pfs->in_surface(current, p, ring_indices)) {
    return false;
  }
  return true;
}

Neighbors::iterator Neighbors::begin() const {
  auto ret = iterator(this, 0, 0);
  if (ret == end()) {
    // Can't dereferfence the end.
    return ret;
  }
  if (is_neighbor(*ret)) {
    // This is a valid begin.
    return ret;
  } else {
    // This position is invalid but we can increment to get to a valid one.
    ++ret;
    return ret;
  }
}

Neighbors::iterator Neighbors::end() const {
  return iterator(this, 2+pfs->vertices().size(), 0);
}

PathFindingSurface::PathFindingSurface(const optional<multi_polygon_type_fp>& keep_in,
                                       const multi_polygon_type_fp& keep_out,
                                       const coordinate_type_fp tolerance) {
  if (!keep_in && keep_out.size() == 0) {
    return;
  }
  if (keep_in) {
    multi_polygon_type_fp total_keep_in = *keep_in - keep_out;

    total_keep_in_grown.emplace();
    for (const auto& poly : total_keep_in) {
      all_vertices.emplace_back(poly.outer().cbegin(), poly.outer().cend());
      total_keep_in_grown->emplace_back(
          bg_helpers::buffer_miter(poly.outer(), tolerance),
          vector<multi_polygon_type_fp>());
      for (const auto& inner : poly.inners()) {
        all_vertices.emplace_back(inner.cbegin(), inner.cend());
        // Because the inner is reversed, we need to reverse it so
        // that the buffer algorithm won't get confused.
        auto temp_inner = inner;
        bg::reverse(temp_inner);
        // tolerance needs to be inverted because growing a shape
        // shrinks the holes in it.
        total_keep_in_grown->back().second.push_back(bg_helpers::buffer_miter(temp_inner, -tolerance));
      }
    }
  } else {
    for (const auto& poly : keep_out){
      all_vertices.emplace_back(poly.outer().cbegin(), poly.outer().cend());
      keep_out_shrunk.emplace_back(
          bg_helpers::buffer_miter(poly.outer(), -tolerance),
          vector<multi_polygon_type_fp>());
      for (const auto& inner : poly.inners()) {
        all_vertices.emplace_back(inner.cbegin(), inner.cend());
        // Because the inner is reversed, we need to reverse it so
        // that the buffer algorithm won't get confused.
        auto temp_inner = inner;
        bg::reverse(temp_inner);
        // tolerance needs to be inverted because shrinking a shape
        // grows the holes in it.
        keep_out_shrunk.back().second.push_back(bg_helpers::buffer_miter(temp_inner, tolerance));
      }
    }
  }

  for (auto av : all_vertices) {
    sort(av.begin(), av.end());
    av.erase(std::unique(av.begin(), av.end()), av.end());
  }
}

vector<size_t> inside_multipolygon(const point_type_fp& p,
                                   const multi_polygon_type_fp& mp) {
  size_t current_ring_index = 0;
  for (const auto& poly : mp) {
    if (point_in_ring(p, poly.outer())) {
      // Might be part of this shape but only if the point isn't in
      // the inners.
      vector<size_t> ring_indices{current_ring_index};
      current_ring_index++;
      for (const auto& inner : poly.inners()) {
        if (!point_in_ring(p, inner)) {
          // We'll have to make sure not to cross this inner.
          ring_indices.push_back(current_ring_index);
          current_ring_index++;
        } else {
          break; // We're inside one of the inners so give up.
        }
      }
      if (ring_indices.size() == poly.inners().size() + 1) {
        // We're inside this shape so we're done.
        return ring_indices;
      } else {
        // We're inside the outer but also inside an inner!  It might
        // be an outer in an inner so we'll ignore this one and keep
        // searching.  Reset the current_ring_index to what it was.
        current_ring_index = ring_indices.front();
        ring_indices.clear();
      }
    }
    current_ring_index += 1 + poly.inners().size();
  }
  return {};
}

vector<size_t> outside_multipolygon(const point_type_fp& p,
                                    const multi_polygon_type_fp& mp) {
  vector<size_t> ring_indices;
  size_t current_ring_index = 0;
  for (const auto& poly : mp) {
    if (point_in_ring(p, poly.outer())) {
      // We're inside the outer, maybe we're in an inner?  If not, we
      // aren't outside at all and we'll just give up.
      bool in_inner = false;
      for (size_t i = 0; i < poly.inners().size(); i++) {
        const auto& inner = poly.inners()[i];
        if (point_in_ring(p, inner)) {
          in_inner = true;
          ring_indices.push_back(current_ring_index + i + 1);
          break;
        }
      }
      if (!in_inner) {
        // We're inside the outer but not in any of the inners, so
        // we're in the shape, but we want to be outside the shape, so
        // we've failed.
        return {};
      }
      current_ring_index += 1 + poly.inners().size();
    } else {
      // We need to keep out of this outer.
      ring_indices.push_back(current_ring_index);
      // No need to examine the inners which we can't possibly be inside.
      current_ring_index += 1 + poly.inners().size();
    }
  }
  return ring_indices;
}

RingIndices inside_multipolygons(
    const point_type_fp& p,
    const nested_multipolygon_type_fp& mp){
  size_t current_ring_index = 0;
  for (const auto& poly : mp) {
    // The loop always starts on an outer.
    auto inside_mp = inside_multipolygon(p, poly.first);
    if (inside_mp.size() > 0) {
      // Might be part of this shape but only if the point isn't in
      // the inners.
      RingIndices ring_indices{{current_ring_index, inside_mp}};
      current_ring_index++;
      for (const auto& inner : poly.second) {
        auto outside_mp = outside_multipolygon(p, inner);
        if (outside_mp.size() > 0) {
          // We'll have to make sure not to cross this inner.
          ring_indices.push_back({current_ring_index, outside_mp});
          current_ring_index++;
        } else {
          break; // We're inside one of the inners so give up.
        }
      }
      if (ring_indices.size() == poly.second.size() + 1) {
        // We never hit the break so we're inside this shape so we're
        // done.
        return ring_indices;
      } else {
        // We're inside the outer but also inside an inner!  It might
        // be an outer in an inner so we'll ignore this one and keep
        // searching.  Reset the current_ring_index to what it was.
        current_ring_index = ring_indices.front().first;
        ring_indices.clear();
      }
    }
    current_ring_index += 1 + poly.second.size();
  }
  return {};
}

RingIndices outside_multipolygons(
    const point_type_fp& p,
    const nested_multipolygon_type_fp& mp) {
  RingIndices ring_indices;
  size_t current_ring_index = 0;
  for (const auto& poly : mp) {
    auto outside_mp = outside_multipolygon(p, poly.first);
    if (outside_mp.size() == 0) {
      // We're inside the outer, maybe we're in an inner?  If not, we
      // aren't outside at all and we'll just give up.
      bool in_inner = false;
      for (size_t i = 0; i < poly.second.size(); i++) {
        const auto& inner = poly.second[i];
        auto inside_mp = inside_multipolygon(p, inner);
        if (inside_mp.size() > 0) {
          in_inner = true;
          ring_indices.push_back({current_ring_index + i + 1, inside_mp});
          break;
        }
      }
      if (!in_inner) {
        // We're inside the outer but not in any of the inners, so
        // we're in the shape, but we want to be outside the shape, so
        // we've failed.
        return {};
      }
      current_ring_index += 1 + poly.second.size();
    } else {
      // We need to keep out of this outer.
      ring_indices.push_back({current_ring_index, outside_mp});
      // No need to examine the inners which we can't possibly be inside.
      current_ring_index += 1 + poly.second.size();
    }
  }
  return ring_indices;
}

/* Given a point, determine if the point is in the search surface.  If
   so, return a non-default value, otherwise default value.  If two
   points return the same value, there is a path between them in the
   surface.  If not then there cannot be a path between them.  The
   value will actually be a vector of size_t that indicates which
   rings in the stored polygon should be used for the generated points
   in the path and also for the collision detection. */
RingIndices PathFindingSurface::in_surface(point_type_fp p) const {
  if (total_keep_in_grown) {
    return inside_multipolygons(p, *total_keep_in_grown);
  } else {
    return outside_multipolygons(p, keep_out_shrunk);
  }
}

bool is_intersecting(const point_type_fp& a, const point_type_fp& b, const ring_type_fp& ring) {
  for (auto current = ring.cbegin(); current + 1 != ring.cend(); current++) {
    if (is_intersecting(a, b, *current, *(current+1))) {
      return true;
    }
  }
  return false;
}

bool is_intersecting(
    const point_type_fp& a, const point_type_fp& b,
    const vector<size_t>& ring_indices,
    const multi_polygon_type_fp& poly_to_search) {
  size_t current_ring = 0;
  size_t current_index = 0;
  for (const auto& poly : poly_to_search) {
    if (ring_indices[current_index] == current_ring) {
      if (is_intersecting(a, b, poly.outer())) {
        return true;
      }
      current_index++;
      if (current_index >= ring_indices.size()) {
        return false; // We've finished our search.
      }
    }
    for (const auto& inner : poly.inners()) {
      current_ring++;
      if (ring_indices[current_index] == current_ring) {
        if (is_intersecting(a, b, inner)) {
          return true;
        }
        current_index++;
        if (current_index >= ring_indices.size()) {
          return false; // We've finished our search.
        }
      }
    }
    current_ring++;
  }
  throw std::logic_error("There were more rings to search than rings.  "
                         "This should never happen.");
}

bool is_intersecting(
    const point_type_fp& a, const point_type_fp& b,
    const RingIndices& ring_indices,
    const nested_multipolygon_type_fp* poly_to_search) {
  size_t current_ring = 0;
  size_t current_index = 0;
  for (const auto& poly : *poly_to_search) {
    if (ring_indices[current_index].first == current_ring) {
      if (is_intersecting(a, b, ring_indices[current_index].second, poly.first)) {
         return true;
      }
      current_index++;
      if (current_index >= ring_indices.size()) {
         return false; // We're finished our search.
      }
    }
    for (const auto& inner : poly.second) {
      current_ring++;
      if (ring_indices[current_index].first == current_ring) {
        if (is_intersecting(a, b, ring_indices[current_index].second, inner)) {
           return true;
        }
        current_index++;
        if (current_index >= ring_indices.size()) {
           return false; // We're finished our search.
        }
      }
    }
    current_ring++;
  }
  throw std::logic_error("There were more rings to search than rings.  "
                         "This should never happen.");
}

// Return true if this edge from a to b is part of the path finding surface.
bool PathFindingSurface::in_surface(
    const point_type_fp& a, const point_type_fp& b,
    const RingIndices& ring_indices) const {
  if (b < a) {
    return in_surface(b, a, ring_indices);
  }
  const auto key = make_pair(a, b);
  auto memoized_result = in_surface_memo.find(key);
  if (memoized_result != in_surface_memo.cend()) {
    return memoized_result->second;
  }
  const nested_multipolygon_type_fp* poly_to_search;
  if (total_keep_in_grown) {
    poly_to_search = &*total_keep_in_grown;
  } else {
    poly_to_search = &keep_out_shrunk;
  }
  auto found_intersection = is_intersecting(a, b, ring_indices, poly_to_search);
  in_surface_memo.emplace(key, !found_intersection);
  return !found_intersection;
}

// Return all possible neighbors of current.  A neighbor can be
// start, end, or any of the points in all_vertices.  But only the
// ones that are in_surface are returned.
Neighbors PathFindingSurface::neighbors(const point_type_fp& start, const point_type_fp& end,
                                        const RingIndices& ring_indices,
                                        coordinate_type_fp g_score_current,
                                        const PathLimiter path_limiter,
                                        const point_type_fp& current) const {
  return Neighbors(start, end, current, ring_indices, g_score_current, path_limiter, this);
}

// Return a path from the start to the current.  Always return at
// least two points.
linestring_type_fp build_path(
    point_type_fp current,
    const unordered_map<point_type_fp, point_type_fp>& came_from) {
  linestring_type_fp result;
  while (came_from.count(current)) {
    result.push_back(current);
    current = came_from.at(current);
  }
  result.push_back(current);
  bg::reverse(result);
  return result;
}

optional<linestring_type_fp> PathFindingSurface::find_path(
    const point_type_fp& start, const point_type_fp& goal,
    const PathLimiter& path_limiter) const {
  RingIndices ring_indices;
  ring_indices = in_surface(start);
  if (ring_indices.size() == 0) {
    // Start is not in the surface.
    return boost::none;
  }
  if (ring_indices != in_surface(goal)) {
    // Either goal is not in the surface or it's in a region unreachable by start.
    return boost::none;
  }

  // Connect if a direct connection is possible.  This also takes care
  // of the case where start == goal.
  linestring_type_fp direct_ls;
  direct_ls.push_back(start);
  direct_ls.push_back(goal);
  try {
    if (in_surface(start, goal, ring_indices) &&
        (path_limiter == nullptr || !path_limiter(goal, bg::distance(start, goal)))) {
      return direct_ls;
    }
  } catch (GiveUp g) {
    return boost::none;
  }

  // Do astar.
  priority_queue<pair<coordinate_type_fp, point_type_fp>,
                 vector<pair<coordinate_type_fp, point_type_fp>>,
                 std::greater<pair<coordinate_type_fp, point_type_fp>>> open_set;
  open_set.emplace(bg::distance(start, goal), start);
  unordered_set<point_type_fp> closed_set;
  unordered_map<point_type_fp, point_type_fp> came_from;
  unordered_map<point_type_fp, coordinate_type_fp> g_score; // Empty should be considered infinity.
  g_score[start] = 0;
  while (!open_set.empty()) {
    const auto current = open_set.top().second;
    open_set.pop();
    if (current == goal) {
      // We're done.
      return make_optional(build_path(current, came_from));
    }
    if (closed_set.count(current) > 0) {
      // Skip this because we already "removed it", sort of.
      continue;
    }
    try {
      const auto current_neighbors = neighbors(
          start, goal, ring_indices, g_score.at(current), path_limiter, current);
      for (const auto& neighbor : current_neighbors) {
        const auto tentative_g_score = g_score.at(current) + bg::distance(current, neighbor);
        if (g_score.count(neighbor) == 0 || tentative_g_score < g_score.at(neighbor)) {
          // This path to neighbor is better than any previous one.
          came_from[neighbor] = current;
          g_score[neighbor] = tentative_g_score;
          open_set.emplace(tentative_g_score + bg::distance(neighbor, goal), neighbor);
        }
      }
    } catch (GiveUp g) {
      return boost::none;
    }
    // Because we can't delete from the open_set, we'll just marked
    // items as closed and ignore them later.
    closed_set.insert(current);
  }
  return boost::none;
}

} //namespace path_finding

1	#include <vector>
2	using std::vector;
3
4	#include <unordered_map>
5	using std::unordered_map;
6
7	#include <unordered_set>
8	using std::unordered_set;
9
10	#include <queue>
11	using std::priority_queue;
12
13	#include <utility>
14	using std::pair;
15	using std::make_pair;
16
17	#include <boost/graph/adjacency_list.hpp>
18	#include <boost/graph/astar_search.hpp>
19	#include <boost/optional.hpp>
20
21	#include "path_finding.hpp"
22	#include "options.hpp"
23	#include "geometry.hpp"
24	#include "bg_operators.hpp"
25	#include "bg_helpers.hpp"
26
27	namespace path_finding {
28
29	using boost::optional;
30	using boost::make_optional;
31
32	Neighbors::iterator Neighbors::iterator::operator++() {	14,334✔
33	do {
34	if (ring_index < 2) {	28,061✔
35	ring_index++;	27,784✔
36	} else {
37	point_index++;	277✔
38	while (ring_index-2 < neighbors->pfs->vertices().size() &&	626✔
39	point_index >= neighbors->pfs->vertices()[ring_index-2].size()) {	566✔
40	ring_index++;	36✔
41	point_index = 0;	36✔
42	}
43	}
44	} while (ring_index < neighbors->pfs->vertices().size()+2 &&	70,013✔
45	!neighbors->is_neighbor(**this));	28,031✔
46	return *this;	194✔
47	}
48
NEW 49	bool Neighbors::iterator::operator!=(const Neighbors::iterator& other) const {	×
50	return ring_index != other.ring_index \|\| point_index != other.point_index;	14,382!
51	}
52
NEW 53	bool Neighbors::iterator::operator==(const Neighbors::iterator& other) const {	×
NEW 54	return !(*this != other);	×
55	}
56
NEW 57	const point_type_fp& Neighbors::iterator::operator*() const {	×
58	if (ring_index == 0) {	28,213!
59	return neighbors->start;	18✔
60	} else if (ring_index == 1) {	28,195!
61	return neighbors->goal;	14,177✔
62	} else {
63	return neighbors->pfs->vertices()[ring_index-2][point_index];	28,036✔
64	}
65	}
66
67	Neighbors::Neighbors(const point_type_fp& start, const point_type_fp& goal,	14,170✔
68	const point_type_fp& current,
69	const RingIndices& ring_indices,
70	coordinate_type_fp g_score_current,
71	const PathLimiter path_limiter,
72	const PathFindingSurface* pfs) :	14,170✔
73	start(start),
74	goal(goal),
75	current(current),
76	ring_indices(ring_indices),
77	g_score_current(g_score_current),
78	path_limiter(path_limiter),
79	pfs(pfs) {}	14,170!
80
81	// Returns a valid neighbor index that is either the one provided or
82	// the next higher valid one.
83	bool Neighbors::is_neighbor(const point_type_fp p) const {	42,201✔
84	if (p == current) {
85	return false;
86	}
87	if (path_limiter != nullptr && path_limiter(p, g_score_current + bg::distance(current, p))) {	41,616!
88	return false;	5,994✔
89	}
90	if (!pfs->in_surface(current, p, ring_indices)) {	7,891✔
91	return false;	7,709✔
92	}
93	return true;
94	}
95
96	Neighbors::iterator Neighbors::begin() const {	14,170!
97	auto ret = iterator(this, 0, 0);
98	if (ret == end()) {
99	// Can't dereferfence the end.
100	return ret;
101	}
102	if (is_neighbor(*ret)) {	14,170✔
103	// This is a valid begin.
104	return ret;
105	} else {
106	// This position is invalid but we can increment to get to a valid one.
107	++ret;	14,152✔
108	return ret;	13✔
109	}
110	}
111
NEW 112	Neighbors::iterator Neighbors::end() const {	×
113	return iterator(this, 2+pfs->vertices().size(), 0);	14,232!
114	}
115
116	PathFindingSurface::PathFindingSurface(const optional<multi_polygon_type_fp>& keep_in,	143✔
117	const multi_polygon_type_fp& keep_out,
118	const coordinate_type_fp tolerance) {	429✔
119	if (!keep_in && keep_out.size() == 0) {	143✔
120	return;
121	}
122	if (keep_in) {	95✔
123	multi_polygon_type_fp total_keep_in = *keep_in - keep_out;	66!
124
125	total_keep_in_grown.emplace();
126	for (const auto& poly : total_keep_in) {	193✔
127	all_vertices.emplace_back(poly.outer().cbegin(), poly.outer().cend());	127!
128	total_keep_in_grown->emplace_back(	127!
129	bg_helpers::buffer_miter(poly.outer(), tolerance),	127!
130	vector<multi_polygon_type_fp>());	127✔
131	for (const auto& inner : poly.inners()) {	446✔
132	all_vertices.emplace_back(inner.cbegin(), inner.cend());	319!
133	// Because the inner is reversed, we need to reverse it so
134	// that the buffer algorithm won't get confused.
135	auto temp_inner = inner;
136	bg::reverse(temp_inner);
137	// tolerance needs to be inverted because growing a shape
138	// shrinks the holes in it.
139	total_keep_in_grown->back().second.push_back(bg_helpers::buffer_miter(temp_inner, -tolerance));	638!
140	}
141	}
142	} else {
143	for (const auto& poly : keep_out){	351✔
144	all_vertices.emplace_back(poly.outer().cbegin(), poly.outer().cend());	322!
145	keep_out_shrunk.emplace_back(	322!
146	bg_helpers::buffer_miter(poly.outer(), -tolerance),	644!
147	vector<multi_polygon_type_fp>());	322✔
148	for (const auto& inner : poly.inners()) {	568✔
149	all_vertices.emplace_back(inner.cbegin(), inner.cend());	246!
150	// Because the inner is reversed, we need to reverse it so
151	// that the buffer algorithm won't get confused.
152	auto temp_inner = inner;
153	bg::reverse(temp_inner);
154	// tolerance needs to be inverted because shrinking a shape
155	// grows the holes in it.
156	keep_out_shrunk.back().second.push_back(bg_helpers::buffer_miter(temp_inner, tolerance));	492!
157	}
158	}
159	}
160
161	for (auto av : all_vertices) {	1,109!
162	sort(av.begin(), av.end());	1,014✔
163	av.erase(std::unique(av.begin(), av.end()), av.end());	1,014✔
164	}
165	}
166
167	vector<size_t> inside_multipolygon(const point_type_fp& p,	39,980✔
168	const multi_polygon_type_fp& mp) {
169	size_t current_ring_index = 0;	39,980✔
170	for (const auto& poly : mp) {	56,118✔
171	if (point_in_ring(p, poly.outer())) {	39,987✔
172	// Might be part of this shape but only if the point isn't in
173	// the inners.
174	vector<size_t> ring_indices{current_ring_index};	23,856!
175	current_ring_index++;	23,856✔
176	for (const auto& inner : poly.inners()) {	23,867✔
177	if (!point_in_ring(p, inner)) {	18✔
178	// We'll have to make sure not to cross this inner.
179	ring_indices.push_back(current_ring_index);	11!
180	current_ring_index++;	11✔
181	} else {
182	break; // We're inside one of the inners so give up.
183	}
184	}
185	if (ring_indices.size() == poly.inners().size() + 1) {	71,568✔
186	// We're inside this shape so we're done.
187	return ring_indices;
188	} else {
189	// We're inside the outer but also inside an inner! It might
190	// be an outer in an inner so we'll ignore this one and keep
191	// searching. Reset the current_ring_index to what it was.
192	current_ring_index = ring_indices.front();	7!
193	ring_indices.clear();
194	}
195	}
196	current_ring_index += 1 + poly.inners().size();	32,276✔
197	}
198	return {};
199	}
200
201	vector<size_t> outside_multipolygon(const point_type_fp& p,	289,558✔
202	const multi_polygon_type_fp& mp) {
203	vector<size_t> ring_indices;
204	size_t current_ring_index = 0;	289,558✔
205	for (const auto& poly : mp) {	574,009✔
206	if (point_in_ring(p, poly.outer())) {	289,571✔
207	// We're inside the outer, maybe we're in an inner? If not, we
208	// aren't outside at all and we'll just give up.
209	bool in_inner = false;
210	for (size_t i = 0; i < poly.inners().size(); i++) {	10,257✔
211	const auto& inner = poly.inners()[i];
212	if (point_in_ring(p, inner)) {	11✔
213	in_inner = true;
214	ring_indices.push_back(current_ring_index + i + 1);	6!
215	break;
216	}
217	}
218	if (!in_inner) {
219	// We're inside the outer but not in any of the inners, so
220	// we're in the shape, but we want to be outside the shape, so
221	// we've failed.
222	return {};
223	}
224	current_ring_index += 1 + poly.inners().size();	12✔
225	} else {
226	// We need to keep out of this outer.
227	ring_indices.push_back(current_ring_index);	284,445!
228	// No need to examine the inners which we can't possibly be inside.
229	current_ring_index += 1 + poly.inners().size();	568,890✔
230	}
231	}
232	return ring_indices;
233	}
234
235	RingIndices inside_multipolygons(	19,546✔
236	const point_type_fp& p,
237	const nested_multipolygon_type_fp& mp){
238	size_t current_ring_index = 0;
239	for (const auto& poly : mp) {	21,938✔
240	// The loop always starts on an outer.
241	auto inside_mp = inside_multipolygon(p, poly.first);	21,688!
242	if (inside_mp.size() > 0) {	21,688✔
243	// Might be part of this shape but only if the point isn't in
244	// the inners.
245	RingIndices ring_indices{{current_ring_index, inside_mp}};	19,744!
246	current_ring_index++;	19,520✔
247	for (const auto& inner : poly.second) {	165,896✔
248	auto outside_mp = outside_multipolygon(p, inner);	146,600!
249	if (outside_mp.size() > 0) {	146,600✔
250	// We'll have to make sure not to cross this inner.
NEW 251	ring_indices.push_back({current_ring_index, outside_mp});	×
252	current_ring_index++;	146,376!
253	} else {
254	break; // We're inside one of the inners so give up.
255	}
256	}
257	if (ring_indices.size() == poly.second.size() + 1) {	58,560✔
258	// We never hit the break so we're inside this shape so we're
259	// done.
260	return ring_indices;	19,296✔
261	} else {
262	// We're inside the outer but also inside an inner! It might
263	// be an outer in an inner so we'll ignore this one and keep
264	// searching. Reset the current_ring_index to what it was.
265	current_ring_index = ring_indices.front().first;	224✔
266	ring_indices.clear();
267	}
268	}
269	current_ring_index += 1 + poly.second.size();	4,784✔
270	}
271	return {};
272	}
273
274	RingIndices outside_multipolygons(	23,381✔
275	const point_type_fp& p,
276	const nested_multipolygon_type_fp& mp) {
277	RingIndices ring_indices;	23,381✔
278	size_t current_ring_index = 0;
279	for (const auto& poly : mp) {	165,761✔
280	auto outside_mp = outside_multipolygon(p, poly.first);	142,947!
281	if (outside_mp.size() == 0) {	142,947✔
282	// We're inside the outer, maybe we're in an inner? If not, we
283	// aren't outside at all and we'll just give up.
284	bool in_inner = false;
285	for (size_t i = 0; i < poly.second.size(); i++) {	23,739✔
286	const auto& inner = poly.second[i];
287	auto inside_mp = inside_multipolygon(p, inner);	18,281!
288	if (inside_mp.size() > 0) {	18,281✔
289	in_inner = true;
290	ring_indices.push_back({current_ring_index + i + 1, inside_mp});	8,648!
291	break;
292	}
293	}
294	if (!in_inner) {
295	// We're inside the outer but not in any of the inners, so
296	// we're in the shape, but we want to be outside the shape, so
297	// we've failed.
298	return {};
299	}
300	current_ring_index += 1 + poly.second.size();	8,648✔
301	} else {
302	// We need to keep out of this outer.
NEW 303	ring_indices.push_back({current_ring_index, outside_mp});	×
304	// No need to examine the inners which we can't possibly be inside.
305	current_ring_index += 1 + poly.second.size();	276,112✔
306	}
307	}
308	return ring_indices;
309	}
310
311	/* Given a point, determine if the point is in the search surface. If
312	so, return a non-default value, otherwise default value. If two
313	points return the same value, there is a path between them in the
314	surface. If not then there cannot be a path between them. The
315	value will actually be a vector of size_t that indicates which
316	rings in the stored polygon should be used for the generated points
317	in the path and also for the collision detection. */
318	RingIndices PathFindingSurface::in_surface(point_type_fp p) const {	42,927✔
319	if (total_keep_in_grown) {	42,927✔
320	return inside_multipolygons(p, *total_keep_in_grown);	19,546✔
321	} else {
322	return outside_multipolygons(p, keep_out_shrunk);	23,381✔
323	}
324	}
325
NEW 326	bool is_intersecting(const point_type_fp& a, const point_type_fp& b, const ring_type_fp& ring) {	×
327	for (auto current = ring.cbegin(); current + 1 != ring.cend(); current++) {	9,573,817!
328	if (is_intersecting(a, b, current, (current+1))) {	4,776,925!
329	return true;
330	}
331	}
332	return false;
333	}
334
335	bool is_intersecting(	37,863✔
336	const point_type_fp& a, const point_type_fp& b,
337	const vector<size_t>& ring_indices,
338	const multi_polygon_type_fp& poly_to_search) {
339	size_t current_ring = 0;
340	size_t current_index = 0;
341	for (const auto& poly : poly_to_search) {	37,889!
342	if (ring_indices[current_index] == current_ring) {	75,778!
343	if (is_intersecting(a, b, poly.outer())) {	37,889✔
344	return true;
345	}
346	current_index++;	28,926✔
347	if (current_index >= ring_indices.size()) {	57,852✔
348	return false; // We've finished our search.
349	}
350	}
351	for (const auto& inner : poly.inners()) {	72✔
352	current_ring++;	46!
353	if (ring_indices[current_index] == current_ring) {	46!
354	if (is_intersecting(a, b, inner)) {	46✔
355	return true;
356	}
357	current_index++;	25✔
358	if (current_index >= ring_indices.size()) {	50!
359	return false; // We've finished our search.
360	}
361	}
362	}
363	current_ring++;	26✔
364	}
365	throw std::logic_error("There were more rings to search than rings. "
NEW 366	"This should never happen.");	×
367	}
368
369	bool is_intersecting(	10,189✔
370	const point_type_fp& a, const point_type_fp& b,
371	const RingIndices& ring_indices,
372	const nested_multipolygon_type_fp* poly_to_search) {
373	size_t current_ring = 0;
374	size_t current_index = 0;
375	for (const auto& poly : *poly_to_search) {	21,467!
376	if (ring_indices[current_index].first == current_ring) {	42,934✔
377	if (is_intersecting(a, b, ring_indices[current_index].second, poly.first)) {	20,719✔
378	return true;
379	}
380	current_index++;	17,764✔
381	if (current_index >= ring_indices.size()) {	35,528✔
382	return false; // We're finished our search.
383	}
384	}
385	for (const auto& inner : poly.second) {	32,885✔
386	current_ring++;	21,607✔
387	if (ring_indices[current_index].first == current_ring) {	43,214✔
388	if (is_intersecting(a, b, ring_indices[current_index].second, inner)) {	17,144✔
389	return true;
390	}
391	current_index++;	11,115✔
392	if (current_index >= ring_indices.size()) {	22,230✔
393	return false; // We're finished our search.
394	}
395	}
396	}
397	current_ring++;	11,278✔
398	}
399	throw std::logic_error("There were more rings to search than rings. "
NEW 400	"This should never happen.");	×
401	}
402
403	// Return true if this edge from a to b is part of the path finding surface.
404	bool PathFindingSurface::in_surface(	25,732✔
405	const point_type_fp& a, const point_type_fp& b,
406	const RingIndices& ring_indices) const {
407	if (b < a) {
408	return in_surface(b, a, ring_indices);	2,912✔
409	}
410	const auto key = make_pair(a, b);
411	auto memoized_result = in_surface_memo.find(key);
412	if (memoized_result != in_surface_memo.cend()) {	22,820✔
413	return memoized_result->second;	12,631✔
414	}
415	const nested_multipolygon_type_fp* poly_to_search;
416	if (total_keep_in_grown) {	10,189✔
417	poly_to_search = &*total_keep_in_grown;
418	} else {
419	poly_to_search = &keep_out_shrunk;	3,714✔
420	}
421	auto found_intersection = is_intersecting(a, b, ring_indices, poly_to_search);	10,189✔
422	in_surface_memo.emplace(key, !found_intersection);	10,189✔
423	return !found_intersection;	10,189✔
424	}
425
426	// Return all possible neighbors of current. A neighbor can be
427	// start, end, or any of the points in all_vertices. But only the
428	// ones that are in_surface are returned.
429	Neighbors PathFindingSurface::neighbors(const point_type_fp& start, const point_type_fp& end,	14,170✔
430	const RingIndices& ring_indices,
431	coordinate_type_fp g_score_current,
432	const PathLimiter path_limiter,
433	const point_type_fp& current) const {
434	return Neighbors(start, end, current, ring_indices, g_score_current, path_limiter, this);	28,340!
435	}
436
437	// Return a path from the start to the current. Always return at
438	// least two points.
439	linestring_type_fp build_path(	7✔
440	point_type_fp current,
441	const unordered_map<point_type_fp, point_type_fp>& came_from) {
442	linestring_type_fp result;
443	while (came_from.count(current)) {	25✔
444	result.push_back(current);	18!
445	current = came_from.at(current);	18✔
446	}
447	result.push_back(current);	7!
448	bg::reverse(result);
449	return result;	7✔
450	}
451
452	optional<linestring_type_fp> PathFindingSurface::find_path(	26,088!
453	const point_type_fp& start, const point_type_fp& goal,
454	const PathLimiter& path_limiter) const {
455	RingIndices ring_indices;	26,088✔
456	ring_indices = in_surface(start);	52,176!
457	if (ring_indices.size() == 0) {	26,088✔
458	// Start is not in the surface.
459	return boost::none;	10,515✔
460	}
461	if (ring_indices != in_surface(goal)) {	31,146!
462	// Either goal is not in the surface or it's in a region unreachable by start.
463	return boost::none;	644✔
464	}
465
466	// Connect if a direct connection is possible. This also takes care
467	// of the case where start == goal.
468	linestring_type_fp direct_ls;
469	direct_ls.push_back(start);	14,929!
470	direct_ls.push_back(goal);	14,929!
471	try {
472	if (in_surface(start, goal, ring_indices) &&	14,929!
473	(path_limiter == nullptr \|\| !path_limiter(goal, bg::distance(start, goal)))) {	16,265!
474	return direct_ls;
475	}
476	} catch (GiveUp g) {	1✔
477	return boost::none;
478	}
479
480	// Do astar.
481	priority_queue<pair<coordinate_type_fp, point_type_fp>,
482	vector<pair<coordinate_type_fp, point_type_fp>>,
483	std::greater<pair<coordinate_type_fp, point_type_fp>>> open_set;
484	open_set.emplace(bg::distance(start, goal), start);	14,148!
485	unordered_set<point_type_fp> closed_set;
486	unordered_map<point_type_fp, point_type_fp> came_from;
487	unordered_map<point_type_fp, coordinate_type_fp> g_score; // Empty should be considered infinity.
488	g_score[start] = 0;	14,148✔
489	while (!open_set.empty()) {	14,178✔
490	const auto current = open_set.top().second;	14,177✔
491	open_set.pop();	14,177✔
492	if (current == goal) {
493	// We're done.
494	return make_optional(build_path(current, came_from));	7!
495	}
496	if (closed_set.count(current) > 0) {	14,170!
497	// Skip this because we already "removed it", sort of.
NEW 498	continue;	×
499	}
500	try {
501	const auto current_neighbors = neighbors(
502	start, goal, ring_indices, g_score.at(current), path_limiter, current);	42,510!
503	for (const auto& neighbor : current_neighbors) {	14,352✔
504	const auto tentative_g_score = g_score.at(current) + bg::distance(current, neighbor);	364✔
505	if (g_score.count(neighbor) == 0 \|\| tentative_g_score < g_score.at(neighbor)) {	301✔
506	// This path to neighbor is better than any previous one.
507	came_from[neighbor] = current;	64!
508	g_score[neighbor] = tentative_g_score;	64!
509	open_set.emplace(tentative_g_score + bg::distance(neighbor, goal), neighbor);	14,204!
510	}
511	}
512	} catch (GiveUp g) {	14,140✔
513	return boost::none;
514	}
515	// Because we can't delete from the open_set, we'll just marked
516	// items as closed and ignore them later.
517	closed_set.insert(current);
518	}
519	return boost::none;	1✔
520	}
521
522	} //namespace path_finding

pcb2gcode / pcb2gcode / 529318615

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous