void GerberImporter::linear_draw_circular_aperture(point_type startpoint, point_type endpoint,
coordinate_type radius, unsigned int circle_points, ring_type& ring)
{
const coordinate_type dx = endpoint.x() - startpoint.x();
const coordinate_type dy = endpoint.y() - startpoint.y();
double angle_step;
double offset;
if (circle_points % 2 == 0)
++circle_points;
if (startpoint.x() > endpoint.x())
swap(startpoint, endpoint);
angle_step = 2 * bg::math::pi<double>() / circle_points;
if (dx == 0)
offset = bg::math::pi<double>();
else
offset = atan(dy / dx) + bg::math::pi<double>() / 2;
for (unsigned int i = 0; i < circle_points / 2 + 1; i++)
ring.push_back(point_type(cos(angle_step * i + offset) * radius + startpoint.x(),
sin(angle_step * i + offset) * radius + startpoint.y()));
offset += bg::math::pi<double>();
for (unsigned int i = 0; i < circle_points / 2 + 1; i++)
ring.push_back(point_type(cos(angle_step * i + offset) * radius + endpoint.x(),
sin(angle_step * i + offset) * radius + endpoint.y()));
bg::correct(ring);
}
void GerberImporter::draw_oval(point_type center, coordinate_type width, coordinate_type height,
coordinate_type hole_diameter, unsigned int circle_points, polygon_type& polygon)
{
double angle_step;
double offset;
coordinate_type x;
coordinate_type y;
coordinate_type radius;
if (circle_points % 2 == 0)
++circle_points;
angle_step = -2 * bg::math::pi<double>() / circle_points;
if (width < height)
{
radius = width / 2;
offset = 0;
x = 0;
y = height / 2 - radius;
}
else
{
radius = height / 2;
offset = -bg::math::pi<double>() / 2;
x = width / 2 - radius;
y = 0;
}
for (unsigned int i = 0; i < circle_points / 2 + 1; i++)
polygon.outer().push_back(point_type(cos(angle_step * i + offset) * radius + center.x() - x,
sin(angle_step * i + offset) * radius + center.y() - y));
offset += bg::math::pi<double>();
for (unsigned int i = 0; i < circle_points / 2 + 1; i++)
polygon.outer().push_back(point_type(cos(angle_step * i + offset) * radius + center.x() + x,
sin(angle_step * i + offset) * radius + center.y() + y));
polygon.outer().push_back(polygon.outer().front());
if (hole_diameter != 0)
{
polygon.inners().resize(1);
draw_regular_polygon(center, hole_diameter, circle_points, 0, false, polygon.inners().front());
}
}
void GerberImporter::draw_regular_polygon(point_type center, coordinate_type diameter, unsigned int vertices,
coordinate_type offset, bool clockwise, ring_type& ring)
{
double angle_step;
if (clockwise)
angle_step = -2 * bg::math::pi<double>() / vertices;
else
angle_step = 2 * bg::math::pi<double>() / vertices;
offset *= bg::math::pi<double>() / 180.0;
for (unsigned int i = 0; i < vertices; i++)
ring.push_back(point_type(cos(angle_step * i + offset) * diameter / 2 + center.x(),
sin(angle_step * i + offset) * diameter / 2 + center.y()));
ring.push_back(ring.front());
}
void GerberImporter::circular_arc(point_type center, coordinate_type radius,
double angle1, double angle2, unsigned int circle_points,
linestring_type& linestring)
{
const unsigned int steps = ceil((angle2 - angle1) / (2 * bg::math::pi<double>()) * circle_points);
const double angle_step = (angle2 - angle1) / steps;
for (unsigned int i = 0; i < steps; i++)
{
const double angle = angle1 + i * angle_step;
linestring.push_back(point_type(cos(angle) * radius + center.x(),
sin(angle) * radius + center.y()));
}
linestring.push_back(point_type(cos(angle2) * radius + center.x(),
sin(angle2) * radius + center.y()));
}
void GerberImporter::draw_rectangle(point_type center, coordinate_type width, coordinate_type height,
coordinate_type hole_diameter, unsigned int circle_points, polygon_type& polygon)
{
const coordinate_type x = center.x();
const coordinate_type y = center.y();
polygon.outer().push_back(point_type(x - width / 2, y - height / 2));
polygon.outer().push_back(point_type(x - width / 2, y + height / 2));
polygon.outer().push_back(point_type(x + width / 2, y + height / 2));
polygon.outer().push_back(point_type(x + width / 2, y - height / 2));
polygon.outer().push_back(polygon.outer().front());
if (hole_diameter != 0)
{
polygon.inners().resize(1);
draw_regular_polygon(center, hole_diameter, circle_points, 0, false, polygon.inners().front());
}
}
void sliceTriangle(const point_type& A,
const point_type& B,
const point_type& C,
const vec_type& N,
SegmentStack& _segmentStack) const
{
using geometry::prim::Segment;
typedef geometry::comp::Compound<Segment> SegmentPlane;
SegmentStack::iterator _Ait = _segmentStack.get(A.z()),
_Bit = _segmentStack.get(B.z()),
_Cit = _segmentStack.get(C.z()),
it;
Point2f _Aproj = A.project(geometry::base::Z);
vec_type b = B - A;
scalar_type _invBz = 1.0 / b.z();
vec_type c = C - A;
scalar_type _invCz = 1.0 / c.z();
vec_type d = C - B;
scalar_type _invDz = 1.0 / d.z();
scalar_type _ratioR, _ratioS, _pos;
Vec2f r,s;
bool _passedB = false;
for (it = _Ait ; it != _Cit && it != _segmentStack.end(); ++it)
{
SegmentPlane* _segmentPlane = &(it->second);
if (it == _Bit) _passedB = true;
if (!_passedB)
{
_pos = it->first - A.z();
_ratioR = _pos * _invCz;
_ratioS = _pos * _invBz;
s(b.x()*_ratioS,b.y()*_ratioS);
} else
{
_pos = it->first;
_ratioR = (_pos - A.z()) * _invCz;
_ratioS = (_pos - B.z()) * _invDz;
s(b.x() + d.x()*_ratioS,b.y() + d.y()*_ratioS);
}
r(c.x()*_ratioR,c.y()*_ratioR);
Point2f _p0 = _Aproj+r, _p1 = _Aproj+s;
Vec2f _normal = _p1 - _p0; // Normal of segment points
if (_normal.sqrLength() == 0.0) continue;
_normal(-_normal[1],_normal[0]);
/// Swap point to assure that points are in proper order to be able to make lineSegments
if (dot(Vec2f(N.x(),N.y()),_normal) > 0.0) std::swap(_p0,_p1);
_segmentPlane->add(Segment(_p0,_p1));
}
}
void GerberImporter::draw_rectangle(point_type point1, point_type point2, coordinate_type height, polygon_type& polygon)
{
const double angle = atan2(point2.y() - point1.y(), point2.x() - point1.x());
const coordinate_type dx = height / 2 * sin(angle);
const coordinate_type dy = height / 2 * cos(angle);
polygon.outer().push_back(point_type(point1.x() + dx, point1.y() - dy));
polygon.outer().push_back(point_type(point1.x() - dx, point1.y() + dy));
polygon.outer().push_back(point_type(point2.x() - dx, point2.y() + dy));
polygon.outer().push_back(point_type(point2.x() + dx, point2.y() - dy));
polygon.outer().push_back(polygon.outer().front());
bg::correct(polygon);
}
void RemoteServerProxy::update_object(uint32_t object_id, double x, double y, char type, point_type points,
bool alive) {
if (alive) {
if (renderers_.find(object_id) != renderers_.end()) {
renderers_[object_id]->update_position(Vector(x, y));
} else if (type == 'b') {
renderers_[object_id] = new BulletRenderer(Vector(x, y), points.front().x());
} else if (type == 'l') {
renderers_[object_id] = new NewLifeRenderer(Vector(x, y), points.front().x());
}
} else if (object_id != object_id_) {
if (renderers_.find(object_id) != renderers_.end()) {
Renderer *render = renderers_[object_id];
renderers_.erase(object_id);
delete render;
}
} else {
if (notify_dead_) {
Logger::info("Perdio todas las vidas");
notifier_("PERDISTE TODAS LAS VIDAS");
notify_dead_ = false;
}
}
}
static inline void set(point_type& p, CoordinateType const& value)
{
p.y(value);
}
static inline CoordinateType get(point_type const& p)
{
return p.y();
}
bool operator()(const point_type& a, const point_type& b) const {
return std::tie(a.x(), a.y()) < std::tie(b.x(), b.y());
}
point_difference_type(const point_type& aSrc,
const point_type& aDst) :
M(aSrc.get_matrix() - aDst.get_matrix()) { };
/**
* Computes the covariance matrix which is the linear interpolation between two matrices, by a fraction.
* \param a The first covariance matrix.
* \param fraction The scalar fraction at which the evaluate the linear interpolation.
* \param b The second covariance matrix.
* \return The interpolated covariance matrix.
*/
point_type move_position_toward(const point_type& a, double fraction, const point_type& b) const {
return point_type(matrix_type(value_type(1.0 - fraction) * a.get_matrix() + value_type(fraction) * b.get_matrix()));
};
/**
* Adds a given covariance matrix difference to a given covariance matrix.
* \param a A covariance matrix.
* \param delta A covariance matrix difference to add to a.
* \return The adjusted covariance matrix.
*/
point_type adjust(const point_type& a, const point_difference_type& delta) const {
return point_type(matrix_type( a.get_matrix() + delta.M ));
};
BoundBox(const Point<THEIR_PRECISION>& minpoint, THEIR_PRECISION2 width, THEIR_PRECISION3 height)
: minpoint(minpoint)
, maxpoint(minpoint)
{
maxpoint.offset(width, height);
}
void GerberImporter::linear_draw_rectangular_aperture(point_type startpoint, point_type endpoint, coordinate_type width,
coordinate_type height, ring_type& ring)
{
if (startpoint.y() > endpoint.y())
swap(startpoint, endpoint);
if (startpoint.x() > endpoint.x())
{
ring.push_back(point_type(startpoint.x() + width / 2, startpoint.y() + height / 2));
ring.push_back(point_type(startpoint.x() + width / 2, startpoint.y() - height / 2));
ring.push_back(point_type(startpoint.x() - width / 2, startpoint.y() - height / 2));
ring.push_back(point_type(endpoint.x() - width / 2, endpoint.y() - height / 2));
ring.push_back(point_type(endpoint.x() - width / 2, endpoint.y() + height / 2));
ring.push_back(point_type(endpoint.x() + width / 2, endpoint.y() + height / 2));
}
else
{
ring.push_back(point_type(startpoint.x() + width / 2, startpoint.y() - height / 2));
ring.push_back(point_type(startpoint.x() - width / 2, startpoint.y() - height / 2));
ring.push_back(point_type(startpoint.x() - width / 2, startpoint.y() + height / 2));
ring.push_back(point_type(endpoint.x() - width / 2, endpoint.y() + height / 2));
ring.push_back(point_type(endpoint.x() + width / 2, endpoint.y() + height / 2));
ring.push_back(point_type(endpoint.x() + width / 2, endpoint.y() - height / 2));
}
bg::correct(ring);
}
shared_ptr<multi_polygon_type> Voronoi::build_voronoi(const multi_polygon_type& input,
coordinate_type bounding_box_offset, coordinate_type max_dist)
{
auto output = make_shared<multi_polygon_type>();
voronoi_diagram_type voronoi_diagram;
voronoi_builder_type voronoi_builder;
vector<segment_type_p> segments;
list<const cell_type *> visited_cells;
size_t segments_num = 0;
ring_type bounding_box_ring;
bg::assign(bounding_box_ring, bg::return_buffer<box_type>(
bg::return_envelope<box_type>(input), bounding_box_offset));
for (const polygon_type& polygon : input)
{
segments_num += polygon.outer().size() - 1;
for (const ring_type& ring : polygon.inners())
{
segments_num += ring.size() - 1;
}
}
segments_num += bounding_box_ring.size() - 1;
segments.reserve(segments_num);
for (const polygon_type& polygon : input)
{
copy_ring(polygon.outer(), segments);
for (const ring_type& ring : polygon.inners())
{
copy_ring(ring, segments);
}
}
copy_ring(bounding_box_ring, segments);
output->resize(input.size());
for (size_t i = 0; i < input.size(); i++)
(*output)[i].inners().resize(input.at(i).inners().size());
boost::polygon::insert(segments.begin(), segments.end(), &voronoi_builder);
voronoi_builder.construct(&voronoi_diagram);
for (const cell_type& cell : voronoi_diagram.cells())
{
if (!cell.is_degenerate())
{
const edge_type *edge = cell.incident_edge();
const cell_type *last_cell = NULL;
const auto found_cell = std::find(visited_cells.begin(), visited_cells.end(), &cell);
bool backwards = false;
if (found_cell == visited_cells.end())
{
pair<const polygon_type *, ring_type *> related_geometries = find_ring(input, cell, *output);
if (related_geometries.first && related_geometries.second)
{
const polygon_type& polygon = *(related_geometries.first);
ring_type& ring = *(related_geometries.second);
do {
if (edge->is_primary())
{
if (edge->is_finite())
{
const point_type startpoint (edge->vertex0()->x(), edge->vertex0()->y());
const point_type endpoint (edge->vertex1()->x(), edge->vertex1()->y());
auto append_remove_extra = [&] (const point_type& point)
{
/*
* This works, but it seems more a workaround than a proper solution.
* Why are these segments here in the first place? FIXME
*/
if (ring.size() >= 2 && bg::equals(point, *(ring.end() - 2)))
ring.pop_back();
else
ring.push_back(point);
};
if (bg::covered_by(startpoint, polygon) && bg::covered_by(endpoint, polygon))
{
ring.clear();
break;
}
if (ring.empty() || startpoint.x() != ring.back().x() || startpoint.y() != ring.back().y())
append_remove_extra(startpoint);
if (edge->is_linear())
append_remove_extra(endpoint);
else
{
vector<point_type_fp_p> sampled_edge;
sample_curved_edge(edge, segments, sampled_edge, max_dist);
for (auto iterator = sampled_edge.begin() + 1; iterator != sampled_edge.end(); iterator++)
append_remove_extra(point_type(iterator->x(), iterator->y()));
}
}
else
{
ring.clear();
break;
}
}
else
{
if (!backwards)
{
const cell_type *current_cell = edge->cell();
const cell_type *next_cell = edge->twin()->cell();
if (next_cell == last_cell)
backwards = true;
else
if (current_cell != &cell)
visited_cells.push_front(current_cell);
last_cell = current_cell;
}
edge = edge->twin();
}
edge = edge->next();
} while (edge != cell.incident_edge());
}
}
else
visited_cells.erase(found_cell);
}
}
bg::correct(*output);
return output;
}
unique_ptr<multi_polygon_type> GerberImporter::render(bool fill_closed_lines, unsigned int points_per_circle)
{
map<int, multi_polygon_type> apertures_map;
ring_type region;
coordinate_type cfactor;
unique_ptr<multi_polygon_type> temp_mpoly (new multi_polygon_type());
bool contour = false;
vector<pair<const gerbv_layer_t *, gerberimporter_layer> >layers (1);
auto layers_equivalent = [](const gerbv_layer_t * const layer1, const gerbv_layer_t * const layer2)
{
const gerbv_step_and_repeat_t& sr1 = layer1->stepAndRepeat;
const gerbv_step_and_repeat_t& sr2 = layer2->stepAndRepeat;
if (layer1->polarity == layer2->polarity &&
sr1.X == sr2.X &&
sr1.Y == sr2.Y &&
sr1.dist_X == sr2.dist_X &&
sr1.dist_Y == sr2.dist_Y)
return true;
else
return false;
};
gerbv_image_t *gerber = project->file[0]->image;
if (gerber->info->polarity != GERBV_POLARITY_POSITIVE)
unsupported_polarity_throw_exception();
if (gerber->netlist->state->unit == GERBV_UNIT_MM)
cfactor = scale / 25.4;
else
cfactor = scale;
layers.front().first = gerber->netlist->layer;
generate_apertures_map(gerber->aperture, apertures_map, points_per_circle, cfactor);
for (gerbv_net_t *currentNet = gerber->netlist; currentNet; currentNet = currentNet->next){
const point_type start (currentNet->start_x * cfactor, currentNet->start_y * cfactor);
const point_type stop (currentNet->stop_x * cfactor, currentNet->stop_y * cfactor);
const double * const parameters = gerber->aperture[currentNet->aperture]->parameter;
multi_polygon_type mpoly;
if (!layers_equivalent(currentNet->layer, layers.back().first))
{
layers.resize(layers.size() + 1);
layers.back().first = currentNet->layer;
}
map<coordinate_type, multi_linestring_type>& paths = layers.back().second.paths;
unique_ptr<multi_polygon_type>& draws = layers.back().second.draws;
auto merge_ring = [&](ring_type& ring)
{
if (ring.size() > 1)
{
polygon_type polygon;
bg::correct(ring);
if (simplify_cutins(ring, polygon))
bg::union_(*draws, polygon, *temp_mpoly);
else
bg::union_(*draws, ring, *temp_mpoly);
ring.clear();
draws.swap(temp_mpoly);
temp_mpoly->clear();
}
};
auto merge_mpoly = [&](multi_polygon_type& mpoly)
{
bg::correct(mpoly);
bg::union_(*draws, mpoly, *temp_mpoly);
mpoly.clear();
draws.swap(temp_mpoly);
temp_mpoly->clear();
};
if (currentNet->interpolation == GERBV_INTERPOLATION_LINEARx1) {
if (currentNet->aperture_state == GERBV_APERTURE_STATE_ON) {
if (contour)
{
if (region.empty())
bg::append(region, start);
bg::append(region, stop);
}
else
{
if (gerber->aperture[currentNet->aperture]->type == GERBV_APTYPE_CIRCLE)
{
linestring_type new_segment;
new_segment.push_back(start);
new_segment.push_back(stop);
merge_paths(paths[coordinate_type(gerber->aperture[currentNet->aperture]->parameter[0] * cfactor / 2)], new_segment);
}
else if (gerber->aperture[currentNet->aperture]->type == GERBV_APTYPE_RECTANGLE)
{
mpoly.resize(1);
linear_draw_rectangular_aperture(start, stop, parameters[0] * cfactor,
parameters[1] * cfactor, mpoly.back().outer());
merge_ring(mpoly.back().outer());
}
else
cerr << "Drawing with an aperture different from a circle "
"or a rectangle is forbidden by the Gerber standard; skipping."
<< endl;
}
}
else if (currentNet->aperture_state == GERBV_APERTURE_STATE_FLASH) {
if (contour)
{
cerr << "D03 during contour mode is forbidden by the Gerber "
"standard; skipping" << endl;
}
else
{
const auto aperture_mpoly = apertures_map.find(currentNet->aperture);
if (aperture_mpoly != apertures_map.end())
bg::transform(aperture_mpoly->second, mpoly, translate(stop.x(), stop.y()));
else
cerr << "Macro aperture " << currentNet->aperture <<
" not found in macros list; skipping" << endl;
merge_mpoly(mpoly);
}
}
else if (currentNet->aperture_state == GERBV_APERTURE_STATE_OFF)
{
if (contour)
{
if (!region.empty())
{
bg::append(region, stop);
merge_ring(region);
}
}
}
else
{
cerr << "Unrecognized aperture state: skipping" << endl;
}
}
else if (currentNet->interpolation == GERBV_INTERPOLATION_PAREA_START)
{
contour = true;
}
else if (currentNet->interpolation == GERBV_INTERPOLATION_PAREA_END)
{
contour = false;
if (!region.empty())
merge_ring(region);
}
else if (currentNet->interpolation == GERBV_INTERPOLATION_CW_CIRCULAR ||
currentNet->interpolation == GERBV_INTERPOLATION_CCW_CIRCULAR)
{
if (currentNet->aperture_state == GERBV_APERTURE_STATE_ON) {
const gerbv_cirseg_t * const cirseg = currentNet->cirseg;
linestring_type path;
if (cirseg != NULL)
{
double angle1;
double angle2;
if (currentNet->interpolation == GERBV_INTERPOLATION_CCW_CIRCULAR)
{
angle1 = cirseg->angle1;
angle2 = cirseg->angle2;
}
else
{
angle1 = cirseg->angle2;
angle2 = cirseg->angle1;
}
circular_arc(point_type(cirseg->cp_x * scale, cirseg->cp_y * scale),
cirseg->width * scale / 2,
angle1 * bg::math::pi<double>() / 180.0,
angle2 * bg::math::pi<double>() / 180.0,
points_per_circle,
path);
if (contour)
{
if (region.empty())
copy(path.begin(), path.end(), region.end());
else
copy(path.begin() + 1, path.end(), region.end());
}
else
{
if (gerber->aperture[currentNet->aperture]->type == GERBV_APTYPE_CIRCLE)
merge_paths(paths[coordinate_type(gerber->aperture[currentNet->aperture]->parameter[0] * cfactor / 2)], path);
else
cerr << "Drawing an arc with an aperture different from a circle "
"is forbidden by the Gerber standard; skipping."
<< endl;
}
}
else
cerr << "Circular arc requested but cirseg == NULL" << endl;
}
else if (currentNet->aperture_state == GERBV_APERTURE_STATE_FLASH) {
cerr << "D03 during circular arc mode is forbidden by the Gerber "
"standard; skipping" << endl;
}
}
else if (currentNet->interpolation == GERBV_INTERPOLATION_x10 ||
currentNet->interpolation == GERBV_INTERPOLATION_LINEARx01 ||
currentNet->interpolation == GERBV_INTERPOLATION_LINEARx001 ) {
cerr << "Linear zoomed interpolation modes are not supported "
"(are them in the RS274X standard?)" << endl;
}
else //if (currentNet->interpolation != GERBV_INTERPOLATION_DELETED)
{
cerr << "Unrecognized interpolation mode" << endl;
}
}
for (pair<const gerbv_layer_t *, gerberimporter_layer>& layer : layers)
{
for (pair<const coordinate_type, multi_linestring_type>& path : layer.second.paths)
{
simplify_paths(path.second);
}
}
return generate_layers(layers, fill_closed_lines, cfactor, points_per_circle);
}