polygon_set transform_figure(polygon_set ps, float A[4][4]) {
size_t s = ps.size();
polygon_set to_return(s);
for (int i = 0 ; i < s ; i++) {
to_return[i] = POLYGON(transform(std::get<0>(ps.at(i)), A),
transform(std::get<1>(ps.at(i)), A),
transform(std::get<2>(ps.at(i)), A));
}
return to_return;
}
static void convolve_two_polygon_sets(polygon_set& result, const polygon_set& a, const polygon_set& b) {
result.clear();
std::vector<polygon> a_polygons;
std::vector<polygon> b_polygons;
a.get(a_polygons);
b.get(b_polygons);
for(std::size_t ai = 0; ai < a_polygons.size(); ++ai) {
convolve_point_sequence_with_polygons(result, begin_points(a_polygons[ai]),
end_points(a_polygons[ai]), b_polygons);
for(typename polygon_with_holes_traits<polygon>::iterator_holes_type itrh = begin_holes(a_polygons[ai]);
itrh != end_holes(a_polygons[ai]); ++itrh) {
convolve_point_sequence_with_polygons(result, begin_points(*itrh),
end_points(*itrh), b_polygons);
}
for(std::size_t bi = 0; bi < b_polygons.size(); ++bi) {
polygon tmp_poly = a_polygons[ai];
result.insert(convolve(tmp_poly, *(begin_points(b_polygons[bi]))));
tmp_poly = b_polygons[bi];
result.insert(convolve(tmp_poly, *(begin_points(a_polygons[ai]))));
}
}
}
inline std::vector<std::set<int> >
extract_layer(connectivity_extraction& ce, std::vector<std::string>& net_ids,
connectivity_database& connectivity, polygon_set& layout,
std::string layer) {
for(connectivity_database::iterator itr = connectivity.begin(); itr != connectivity.end(); ++itr) {
net_ids.push_back((*itr).first);
ce.insert((*itr).second[layer]);
}
std::vector<polygon> polygons;
layout.get_polygons(polygons);
for(std::size_t i = 0; i < polygons.size(); ++i) {
ce.insert(polygons[i]);
}
std::vector<std::set<int> > graph(polygons.size() + net_ids.size(), std::set<int>());
ce.extract(graph);
return graph;
}
static void convolve_two_point_sequences(polygon_set& result, itrT1 ab, itrT1 ae, itrT2 bb, itrT2 be) {
if(ab == ae || bb == be)
return;
point first_a = *ab;
point prev_a = *ab;
std::vector<point> vec;
polygon poly;
++ab;
for( ; ab != ae; ++ab) {
point first_b = *bb;
point prev_b = *bb;
itrT2 tmpb = bb;
++tmpb;
for( ; tmpb != be; ++tmpb) {
convolve_two_segments(vec, std::make_pair(prev_b, *tmpb), std::make_pair(prev_a, *ab));
set_points(poly, vec.begin(), vec.end());
result.insert(poly);
prev_b = *tmpb;
}
prev_a = *ab;
}
}
inline void connect_layout_to_layer(connectivity_database& connectivity, polygon_set& layout, std::string layout_layer, std::string layer, std::string net_prefix, int& net_suffix) {
if(layout_layer.empty())
return;
boost::polygon::connectivity_extraction_90<int> ce;
std::vector<std::string> net_ids;
for(connectivity_database::iterator itr = connectivity.begin(); itr != connectivity.end(); ++itr) {
net_ids.push_back((*itr).first);
ce.insert((*itr).second[layer]);
}
std::vector<polygon> polygons;
layout.get_polygons(polygons);
std::size_t polygon_id_offset = net_ids.size();
for(std::size_t i = 0; i < polygons.size(); ++i) {
ce.insert(polygons[i]);
}
std::vector<std::set<int> > graph(polygons.size() + net_ids.size(), std::set<int>());
ce.extract(graph);
std::vector<int> polygon_color(polygons.size() + net_ids.size(), 0);
//for each net in net_ids populate connected component with net
for(std::size_t node_id = 0; node_id < net_ids.size(); ++node_id) {
populate_connected_component(connectivity, polygons, polygon_color, graph, node_id,
polygon_id_offset, net_ids[node_id], net_ids,
net_prefix, layout_layer);
}
//for each polygon_color that is zero populate connected compontent with net_prefix + net_suffix++
for(std::size_t i = 0; i < polygons.size(); ++i) {
if(polygon_color[i + polygon_id_offset] == 0) {
std::stringstream ss(std::stringstream::in | std::stringstream::out);
ss << net_prefix << net_suffix++;
std::string internal_net;
ss >> internal_net;
populate_connected_component(connectivity, polygons, polygon_color, graph,
i + polygon_id_offset,
polygon_id_offset, internal_net, net_ids,
net_prefix, layout_layer);
}
}
