151856315

Build Type

github

Committed by GitHub

Commit Message

Merge 8f5b2cfd8 into 664ad3a58

Pull Request Pull Request #462: Orient all segments, whether or not they are reversible.

Run Details

4525 of 7809 branches covered (57.95%)

Branch coverage included in aggregate %.

13 of 14 new or added lines in 2 files covered. (92.86%)

7 existing lines in 2 files now uncovered.

3095 of 3346 relevant lines covered (92.5%)

36550.8 hits per line

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

76.32

/segmentize.cpp

#include <vector>
#include <map>

#include "geometry_int.hpp"
#include "geometry.hpp"
#include "merge_near_points.hpp"
#include <boost/polygon/isotropy.hpp>
#include <boost/polygon/segment_concept.hpp>
#include <boost/polygon/segment_utils.hpp>

namespace segmentize {

using std::vector;
using std::pair;
using std::make_pair;
using std::sort;
using std::unique;

// For use when we have to convert from float to long and back.
const double SCALE = 1000000.0;

// Returns the sign of the input as -1,0,1 for negative/zero/positive.
template <typename T>
int sgn(T val) {
  return (T(0) < val) - (val < T(0));
}

/* Given a multi_linestring, return a new multiline_string where there
 * are no segments that cross any other segments.  Nor are there any T
 * shapes where the end of a linestring butts up against the center of
 * another.
 *
 * For each segment there is a boolean that is true if the segment is
 * reversible.  Non-reversible segments are re-oriented if needed.
 */
static inline vector<pair<segment_type_p, bool>> segmentize(
    const vector<segment_type_p>& all_segments,
    const vector<bool>& allow_reversals) {
  vector<pair<size_t, segment_type_p>> intersected_segment_pairs;
  boost::polygon::intersect_segments(intersected_segment_pairs, all_segments.cbegin(), all_segments.cend());
  vector<pair<segment_type_p, bool>> intersected_segments;
  for (const auto& p : intersected_segment_pairs) {
    const auto index_in_input = p.first;
    const auto& allow_reversal = allow_reversals[index_in_input];
    intersected_segments.push_back(make_pair(p.second, allow_reversal));
    // Reverse segments that are now pointing in the wrong direction.
    const auto& input_segment = all_segments[index_in_input];
    auto& new_segment = intersected_segments.back().first;
    auto input_delta_x = input_segment.high().x() - input_segment.low().x();
    auto input_delta_y = input_segment.high().y() - input_segment.low().y();
    auto new_delta_x = new_segment.high().x() - new_segment.low().x();
    auto new_delta_y = new_segment.high().y() - new_segment.low().y();
    if (sgn(input_delta_x) != sgn(new_delta_x) ||
        sgn(input_delta_y) != sgn(new_delta_y)) {
      // Swap low and high.
      auto low = new_segment.low();
      new_segment.low(new_segment.high());
      new_segment.high(low);
    }
  }

  return intersected_segments;
}

// Convert each linestring, which might have multiple points in it,
// into a linestrings that have just two points, the start and the
// end.  Directionality is maintained on each one along with whether
// or not it is reversible.
vector<pair<linestring_type_fp, bool>> segmentize_paths(const vector<pair<linestring_type_fp, bool>>& toolpaths) {
  // Merge points that are very close to each other because it makes
  // us more likely to find intersections that was can use.
  auto merged_toolpaths = toolpaths;
  merge_near_points(merged_toolpaths, 0.00001);

  // First we need to split all paths so that they don't cross.  We need to
  // scale them up because the input is not floating point.
  vector<segment_type_p> all_segments;
  vector<bool> allow_reversals;
  for (const auto& toolpath_and_allow_reversal : merged_toolpaths) {
    const auto& toolpath = toolpath_and_allow_reversal.first;
    for (size_t i = 1; i < toolpath.size(); i++) {
      all_segments.push_back(
          segment_type_p(
              point_type_p(toolpath[i-1].x() * SCALE, toolpath[i-1].y() * SCALE),
              point_type_p(toolpath[i  ].x() * SCALE, toolpath[i  ].y() * SCALE)));
      allow_reversals.push_back(toolpath_and_allow_reversal.second);
    }
  }
  vector<pair<segment_type_p, bool>> split_segments = segmentize(all_segments, allow_reversals);

  // Only allow reversing the direction of travel if mill_feed_direction is
  // ANY.  We need to scale them back down.
  vector<pair<linestring_type_fp, bool>> segments_as_linestrings;
  segments_as_linestrings.reserve(split_segments.size());
  for (const auto& segment_and_allow_reversal : split_segments) {
    // Make a little 1-edge linestrings.
    linestring_type_fp ls;
    const auto& segment = segment_and_allow_reversal.first;
    const auto& allow_reversal = segment_and_allow_reversal.second;
    ls.push_back(point_type_fp(segment.low().x() / SCALE, segment.low().y() / SCALE));
    ls.push_back(point_type_fp(segment.high().x() / SCALE, segment.high().y() / SCALE));
    segments_as_linestrings.push_back(make_pair(ls, allow_reversal));
  }
  return segments_as_linestrings;
}

} //namespace segmentize

1	#include <vector>
2	#include <map>
3
4	#include "geometry_int.hpp"
5	#include "geometry.hpp"
6	#include "merge_near_points.hpp"
7	#include <boost/polygon/isotropy.hpp>
8	#include <boost/polygon/segment_concept.hpp>
9	#include <boost/polygon/segment_utils.hpp>
10
11	namespace segmentize {
12
13	using std::vector;
14	using std::pair;
15	using std::make_pair;
16	using std::sort;
17	using std::unique;
18
19	// For use when we have to convert from float to long and back.
20	const double SCALE = 1000000.0;
21
22	// Returns the sign of the input as -1,0,1 for negative/zero/positive.
23	template <typename T>
24	int sgn(T val) {
25	return (T(0) < val) - (val < T(0));	550,106✔
26	}
27
28	/* Given a multi_linestring, return a new multiline_string where there
29	* are no segments that cross any other segments. Nor are there any T
30	* shapes where the end of a linestring butts up against the center of
31	* another.
32	*
33	* For each segment there is a boolean that is true if the segment is
34	* reversible. Non-reversible segments are re-oriented if needed.
35	*/
36	static inline vector<pair<segment_type_p, bool>> segmentize(	2,394!
37	const vector<segment_type_p>& all_segments,
38	const vector<bool>& allow_reversals) {
39	vector<pair<size_t, segment_type_p>> intersected_segment_pairs;
40	boost::polygon::intersect_segments(intersected_segment_pairs, all_segments.cbegin(), all_segments.cend());	2,394!
41	vector<pair<segment_type_p, bool>> intersected_segments;
42	for (const auto& p : intersected_segment_pairs) {	364,551✔
43	const auto index_in_input = p.first;	362,157✔
44	const auto& allow_reversal = allow_reversals[index_in_input];	362,157✔
NEW 45	intersected_segments.push_back(make_pair(p.second, allow_reversal));	×
46	// Reverse segments that are now pointing in the wrong direction.
47	const auto& input_segment = all_segments[index_in_input];	362,157✔
48	auto& new_segment = intersected_segments.back().first;
49	auto input_delta_x = input_segment.high().x() - input_segment.low().x();	362,157✔
50	auto input_delta_y = input_segment.high().y() - input_segment.low().y();	362,157✔
51	auto new_delta_x = new_segment.high().x() - new_segment.low().x();	362,157✔
52	auto new_delta_y = new_segment.high().y() - new_segment.low().y();	362,157✔
53	if (sgn(input_delta_x) != sgn(new_delta_x) \|\|	362,157✔
54	sgn(input_delta_y) != sgn(new_delta_y)) {
55	// Swap low and high.
56	auto low = new_segment.low();
57	new_segment.low(new_segment.high());
58	new_segment.high(low);
59	}
60	}
61
62	return intersected_segments;	2,394✔
63	}
64
65	// Convert each linestring, which might have multiple points in it,
66	// into a linestrings that have just two points, the start and the
67	// end. Directionality is maintained on each one along with whether
68	// or not it is reversible.
69	vector<pair<linestring_type_fp, bool>> segmentize_paths(const vector<pair<linestring_type_fp, bool>>& toolpaths) {	2,394✔
70	// Merge points that are very close to each other because it makes
71	// us more likely to find intersections that was can use.
72	auto merged_toolpaths = toolpaths;	4,788✔
73	merge_near_points(merged_toolpaths, 0.00001);	2,394!
74
75	// First we need to split all paths so that they don't cross. We need to
76	// scale them up because the input is not floating point.
77	vector<segment_type_p> all_segments;
78	vector<bool> allow_reversals;
79	for (const auto& toolpath_and_allow_reversal : merged_toolpaths) {	11,996✔
80	const auto& toolpath = toolpath_and_allow_reversal.first;
81	for (size_t i = 1; i < toolpath.size(); i++) {	383,369✔
82	all_segments.push_back(
UNCOV 83	segment_type_p(	×
84	point_type_p(toolpath[i-1].x() * SCALE, toolpath[i-1].y() * SCALE),	364,165✔
85	point_type_p(toolpath[i ].x() * SCALE, toolpath[i ].y() * SCALE)));	364,165✔
86	allow_reversals.push_back(toolpath_and_allow_reversal.second);	364,165!
87	}
88	}
89	vector<pair<segment_type_p, bool>> split_segments = segmentize(all_segments, allow_reversals);	2,394!
90
91	// Only allow reversing the direction of travel if mill_feed_direction is
92	// ANY. We need to scale them back down.
93	vector<pair<linestring_type_fp, bool>> segments_as_linestrings;
94	segments_as_linestrings.reserve(split_segments.size());	4,788!
95	for (const auto& segment_and_allow_reversal : split_segments) {	364,551✔
96	// Make a little 1-edge linestrings.
97	linestring_type_fp ls;
98	const auto& segment = segment_and_allow_reversal.first;
99	const auto& allow_reversal = segment_and_allow_reversal.second;
100	ls.push_back(point_type_fp(segment.low().x() / SCALE, segment.low().y() / SCALE));	362,157!
101	ls.push_back(point_type_fp(segment.high().x() / SCALE, segment.high().y() / SCALE));	362,157!
102	segments_as_linestrings.push_back(make_pair(ls, allow_reversal));	362,157!
103	}
104	return segments_as_linestrings;	2,394✔
105	}
106
107	} //namespace segmentize

pcb2gcode / pcb2gcode / 151856315

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