luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed embarrassing typo: Minkowsky -> Minkowski (Hermann Minkowski, 22 June 1864 – 12 January 1909)

This commit is contained in:
Matthias Koefferlein 2021-06-10 23:33:49 +02:00
parent afeb50b2ac
commit 43c941004a
12 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/db/db/dbPolygonTools.cc
View File

@ -2140,7 +2140,7 @@ ms_extraction (db::EdgeProcessor &ep, bool resolve_holes)
}
static db::Polygon
do_minkowsky_sum (const db::Polygon &a, const db::Edge &b, bool resolve_holes)
do_minkowski_sum (const db::Polygon &a, const db::Edge &b, bool resolve_holes)
{
db::EdgeProcessor ep;
db::ms_production (a, b.p1 (), b.p2 (), ep);
@ -2148,17 +2148,17 @@ do_minkowsky_sum (const db::Polygon &a, const db::Edge &b, bool resolve_holes)
}
db::Polygon
minkowsky_sum (const db::Polygon &a, const db::Edge &b, bool rh)
minkowski_sum (const db::Polygon &a, const db::Edge &b, bool rh)
{
if (a.holes () > 0) {
return do_minkowsky_sum (db::resolve_holes (a), b, rh);
return do_minkowski_sum (db::resolve_holes (a), b, rh);
} else {
return do_minkowsky_sum (a, b, rh);
return do_minkowski_sum (a, b, rh);
}
}
static db::Polygon
do_minkowsky_sum (const db::Polygon &a, const db::Polygon &b, bool resolve_holes)
do_minkowski_sum (const db::Polygon &a, const db::Polygon &b, bool resolve_holes)
{
tl_assert (a.begin_hull () != a.end_hull ());
@ -2174,33 +2174,33 @@ do_minkowsky_sum (const db::Polygon &a, const db::Polygon &b, bool resolve_holes
}
db::Polygon
minkowsky_sum (const db::Polygon &a, const db::Polygon &b, bool rh)
minkowski_sum (const db::Polygon &a, const db::Polygon &b, bool rh)
{
if (a.holes () > 0) {
return do_minkowsky_sum (db::resolve_holes (a), b, rh);
return do_minkowski_sum (db::resolve_holes (a), b, rh);
} else {
return do_minkowsky_sum (a, b, rh);
return do_minkowski_sum (a, b, rh);
}
}
static db::Polygon
do_minkowsky_sum (const db::Polygon &a, const db::Box &b, bool resolve_holes)
do_minkowski_sum (const db::Polygon &a, const db::Box &b, bool resolve_holes)
{
return minkowsky_sum (a, db::Polygon (b), resolve_holes);
return minkowski_sum (a, db::Polygon (b), resolve_holes);
}
db::Polygon
minkowsky_sum (const db::Polygon &a, const db::Box &b, bool rh)
minkowski_sum (const db::Polygon &a, const db::Box &b, bool rh)
{
if (a.holes () > 0) {
return do_minkowsky_sum (db::resolve_holes (a), b, rh);
return do_minkowski_sum (db::resolve_holes (a), b, rh);
} else {
return do_minkowsky_sum (a, b, rh);
return do_minkowski_sum (a, b, rh);
}
}
static db::Polygon
do_minkowsky_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool resolve_holes)
do_minkowski_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool resolve_holes)
{
db::EdgeProcessor ep;
for (size_t i = 1; i < c.size (); ++i) {
@ -2211,12 +2211,12 @@ do_minkowsky_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool re
}
db::Polygon
minkowsky_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool rh)
minkowski_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool rh)
{
if (a.holes () > 0) {
return do_minkowsky_sum (db::resolve_holes (a), c, rh);
return do_minkowski_sum (db::resolve_holes (a), c, rh);
} else {
return do_minkowsky_sum (a, c, rh);
return do_minkowski_sum (a, c, rh);
}
}

8
src/db/db/dbPolygonTools.h
View File

@ -651,22 +651,22 @@ bool DB_PUBLIC rasterize (const db::Polygon &polygon, db::AreaMap &am);
/**
* @brief Minkowski sum of an edge and a polygon
*/
db::Polygon DB_PUBLIC minkowsky_sum (const db::Polygon &a, const db::Edge &b, bool resolve_holes = false);
db::Polygon DB_PUBLIC minkowski_sum (const db::Polygon &a, const db::Edge &b, bool resolve_holes = false);
/**
* @brief Minkowski sum of a polygon and a polygon
*/
db::Polygon DB_PUBLIC minkowsky_sum (const db::Polygon &a, const db::Polygon &b, bool resolve_holes = false);
db::Polygon DB_PUBLIC minkowski_sum (const db::Polygon &a, const db::Polygon &b, bool resolve_holes = false);
/**
* @brief Minkowski sum of a polygon and a box
*/
db::Polygon DB_PUBLIC minkowsky_sum (const db::Polygon &a, const db::Box &b, bool resolve_holes = false);
db::Polygon DB_PUBLIC minkowski_sum (const db::Polygon &a, const db::Box &b, bool resolve_holes = false);
/**
* @brief Minkowski sum of a polygon and a contour
*/
db::Polygon DB_PUBLIC minkowsky_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool resolve_holes = false);
db::Polygon DB_PUBLIC minkowski_sum (const db::Polygon &a, const std::vector<db::Point> &c, bool resolve_holes = false);
/**
* @brief Resolve holes

6
src/db/db/dbRegionProcessors.h
View File

@ -410,11 +410,11 @@ private:
* The object can be Edge, Polygon, Box and std::vector<Point>
*/
template <class K>
class DB_PUBLIC_TEMPLATE minkowsky_sum_computation
class DB_PUBLIC_TEMPLATE minkowski_sum_computation
: public db::PolygonProcessorBase
{
public:
minkowsky_sum_computation (const K &q)
minkowski_sum_computation (const K &q)
: m_q (q)
{
// .. nothing yet ..
@ -422,7 +422,7 @@ public:
void process (const db::Polygon &poly, std::vector<db::Polygon> &result) const
{
result.push_back (db::minkowsky_sum (poly, m_q, false));
result.push_back (db::minkowski_sum (poly, m_q, false));
}
// TODO: could be less if the object is symmetric

24
src/db/db/gsiDeclDbCompoundOperation.cc
View File

@ -289,28 +289,28 @@ static db::CompoundRegionOperationNode *new_merged (db::CompoundRegionOperationN
return new db::CompoundRegionMergeOperationNode (min_coherence, min_wc, input);
}
static db::CompoundRegionOperationNode *new_minkowsky_sum_node1 (db::CompoundRegionOperationNode *input, const db::Edge &e)
static db::CompoundRegionOperationNode *new_minkowski_sum_node1 (db::CompoundRegionOperationNode *input, const db::Edge &e)
{
check_non_null (input, "input");
return new db::CompoundRegionProcessingOperationNode (new db::minkowsky_sum_computation<db::Edge> (e), input, true /*processor is owned*/);
return new db::CompoundRegionProcessingOperationNode (new db::minkowski_sum_computation<db::Edge> (e), input, true /*processor is owned*/);
}
static db::CompoundRegionOperationNode *new_minkowsky_sum_node2 (db::CompoundRegionOperationNode *input, const db::Polygon &p)
static db::CompoundRegionOperationNode *new_minkowski_sum_node2 (db::CompoundRegionOperationNode *input, const db::Polygon &p)
{
check_non_null (input, "input");
return new db::CompoundRegionProcessingOperationNode (new db::minkowsky_sum_computation<db::Polygon> (p), input, true /*processor is owned*/);
return new db::CompoundRegionProcessingOperationNode (new db::minkowski_sum_computation<db::Polygon> (p), input, true /*processor is owned*/);
}
static db::CompoundRegionOperationNode *new_minkowsky_sum_node3 (db::CompoundRegionOperationNode *input, const db::Box &p)
static db::CompoundRegionOperationNode *new_minkowski_sum_node3 (db::CompoundRegionOperationNode *input, const db::Box &p)
{
check_non_null (input, "input");
return new db::CompoundRegionProcessingOperationNode (new db::minkowsky_sum_computation<db::Box> (p), input, true /*processor is owned*/);
return new db::CompoundRegionProcessingOperationNode (new db::minkowski_sum_computation<db::Box> (p), input, true /*processor is owned*/);
}
static db::CompoundRegionOperationNode *new_minkowsky_sum_node4 (db::CompoundRegionOperationNode *input, const std::vector<db::Point> &p)
static db::CompoundRegionOperationNode *new_minkowski_sum_node4 (db::CompoundRegionOperationNode *input, const std::vector<db::Point> &p)
{
check_non_null (input, "input");
return new db::CompoundRegionProcessingOperationNode (new db::minkowsky_sum_computation<std::vector<db::Point> > (p), input, true /*processor is owned*/);
return new db::CompoundRegionProcessingOperationNode (new db::minkowski_sum_computation<std::vector<db::Point> > (p), input, true /*processor is owned*/);
}
static db::CompoundRegionOperationNode *new_edges (db::CompoundRegionOperationNode *input)
@ -640,16 +640,16 @@ Class<db::CompoundRegionOperationNode> decl_CompoundRegionOperationNode ("db", "
gsi::constructor ("new_merged", &new_merged, gsi::arg ("input"), gsi::arg ("min_coherence", false), gsi::arg ("min_wc", 0),
"@brief Creates a node providing merged input polygons.\n"
) +
gsi::constructor ("new_minkowsky_sum", &new_minkowsky_sum_node1, gsi::arg ("input"), gsi::arg ("e"),
gsi::constructor ("new_minkowski_sum|#new_minkowsky_sum", &new_minkowski_sum_node1, gsi::arg ("input"), gsi::arg ("e"),
"@brief Creates a node providing a Minkowski sum with an edge.\n"
) +
gsi::constructor ("new_minkowsky_sum", &new_minkowsky_sum_node2, gsi::arg ("input"), gsi::arg ("p"),
gsi::constructor ("new_minkowski_sum|#new_minkowsky_sum", &new_minkowski_sum_node2, gsi::arg ("input"), gsi::arg ("p"),
"@brief Creates a node providing a Minkowski sum with a polygon.\n"
) +
gsi::constructor ("new_minkowsky_sum", &new_minkowsky_sum_node3, gsi::arg ("input"), gsi::arg ("p"),
gsi::constructor ("new_minkowski_sum|#new_minkowsky_sum", &new_minkowski_sum_node3, gsi::arg ("input"), gsi::arg ("p"),
"@brief Creates a node providing a Minkowski sum with a box.\n"
) +
gsi::constructor ("new_minkowsky_sum", &new_minkowsky_sum_node4, gsi::arg ("input"), gsi::arg ("p"),
gsi::constructor ("new_minkowski_sum|#new_minkowsky_sum", &new_minkowski_sum_node4, gsi::arg ("input"), gsi::arg ("p"),
"@brief Creates a node providing a Minkowski sum with a point sequence forming a contour.\n"
) +
gsi::constructor ("new_width_check", &new_width_check, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::Euclidian, "Euclidian"), gsi::arg ("ignore_angle", tl::Variant (), "default"), gsi::arg ("min_projection", tl::Variant (), "0"), gsi::arg ("max_projection", tl::Variant (), "max."), gsi::arg ("shielded", true), gsi::arg ("negative", false),

48
src/db/db/gsiDeclDbPolygon.cc
View File

@ -567,34 +567,34 @@ struct simple_polygon_defs
}
};
static db::Polygon sp_minkowsky_sum_pe (const db::SimplePolygon *sp, const db::Edge &e, bool rh)
static db::Polygon sp_minkowski_sum_pe (const db::SimplePolygon *sp, const db::Edge &e, bool rh)
{
db::Polygon p;
p.assign_hull (sp->begin_hull (), sp->end_hull (), false);
return db::minkowsky_sum (p, e, rh);
return db::minkowski_sum (p, e, rh);
}
static db::Polygon sp_minkowsky_sum_pp (const db::SimplePolygon *sp, const db::SimplePolygon &spp, bool rh)
static db::Polygon sp_minkowski_sum_pp (const db::SimplePolygon *sp, const db::SimplePolygon &spp, bool rh)
{
db::Polygon p;
p.assign_hull (sp->begin_hull (), sp->end_hull (), false);
db::Polygon pp;
pp.assign_hull (spp.begin_hull (), spp.end_hull (), false);
return db::minkowsky_sum (p, pp, rh);
return db::minkowski_sum (p, pp, rh);
}
static db::Polygon sp_minkowsky_sum_pb (const db::SimplePolygon *sp, const db::Box &b, bool rh)
static db::Polygon sp_minkowski_sum_pb (const db::SimplePolygon *sp, const db::Box &b, bool rh)
{
db::Polygon p;
p.assign_hull (sp->begin_hull (), sp->end_hull (), false);
return db::minkowsky_sum (p, b, rh);
return db::minkowski_sum (p, b, rh);
}
static db::Polygon sp_minkowsky_sum_pc (const db::SimplePolygon *sp, const std::vector<db::Point> &c, bool rh)
static db::Polygon sp_minkowski_sum_pc (const db::SimplePolygon *sp, const std::vector<db::Point> &c, bool rh)
{
db::Polygon p;
p.assign_hull (sp->begin_hull (), sp->end_hull (), false);
return db::minkowsky_sum (p, c, rh);
return db::minkowski_sum (p, c, rh);
}
static db::DSimplePolygon *transform_cplx_sp (db::DSimplePolygon *p, const db::DCplxTrans &t)
@ -638,7 +638,7 @@ Class<db::SimplePolygon> decl_SimplePolygon ("db", "SimplePolygon",
"\n"
"This method has been introduced in version 0.25."
) +
method_ext ("minkowsky_sum", &sp_minkowsky_sum_pe, gsi::arg ("e"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &sp_minkowski_sum_pe, gsi::arg ("e"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of a polygon and an edge\n"
"\n"
"@param e The edge.\n"
@ -648,7 +648,7 @@ Class<db::SimplePolygon> decl_SimplePolygon ("db", "SimplePolygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &sp_minkowsky_sum_pp, gsi::arg ("p"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &sp_minkowski_sum_pp, gsi::arg ("p"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of a polygon and a polygon\n"
"\n"
"@param p The other polygon.\n"
@ -658,7 +658,7 @@ Class<db::SimplePolygon> decl_SimplePolygon ("db", "SimplePolygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &sp_minkowsky_sum_pb, gsi::arg ("b"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &sp_minkowski_sum_pb, gsi::arg ("b"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of a polygon and a box\n"
"\n"
"@param b The box.\n"
@ -668,7 +668,7 @@ Class<db::SimplePolygon> decl_SimplePolygon ("db", "SimplePolygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &sp_minkowsky_sum_pc, gsi::arg ("c"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &sp_minkowski_sum_pc, gsi::arg ("c"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of a polygon and a contour of points (a trace)\n"
"\n"
"@param c The contour (a series of points forming the trace).\n"
@ -1607,24 +1607,24 @@ static db::Polygon smooth (const db::Polygon *p, db::Coord d, bool keep_hv)
return db::smooth (*p, d, keep_hv);
}
static db::Polygon minkowsky_sum_pe (const db::Polygon *p, const db::Edge &e, bool rh)
static db::Polygon minkowski_sum_pe (const db::Polygon *p, const db::Edge &e, bool rh)
{
return db::minkowsky_sum (*p, e, rh);
return db::minkowski_sum (*p, e, rh);
}
static db::Polygon minkowsky_sum_pp (const db::Polygon *p, const db::Polygon &pp, bool rh)
static db::Polygon minkowski_sum_pp (const db::Polygon *p, const db::Polygon &pp, bool rh)
{
return db::minkowsky_sum (*p, pp, rh);
return db::minkowski_sum (*p, pp, rh);
}
static db::Polygon minkowsky_sum_pb (const db::Polygon *p, const db::Box &b, bool rh)
static db::Polygon minkowski_sum_pb (const db::Polygon *p, const db::Box &b, bool rh)
{
return db::minkowsky_sum (*p, b, rh);
return db::minkowski_sum (*p, b, rh);
}
static db::Polygon minkowsky_sum_pc (const db::Polygon *p, const std::vector<db::Point> &c, bool rh)
static db::Polygon minkowski_sum_pc (const db::Polygon *p, const std::vector<db::Point> &c, bool rh)
{
return db::minkowsky_sum (*p, c, rh);
return db::minkowski_sum (*p, c, rh);
}
static db::Polygon *polygon_from_dpolygon (const db::DPolygon &p)
@ -1800,7 +1800,7 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
"\n"
"This method was introduced in version 0.23. The 'keep_hv' optional parameter was added in version 0.27.\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pe, gsi::arg ("e"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pe, gsi::arg ("e"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of the polygon and an edge\n"
"\n"
"@param e The edge.\n"
@ -1814,7 +1814,7 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pp, gsi::arg ("b"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pp, gsi::arg ("b"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of the polygon and a polygon\n"
"\n"
"@param p The first argument.\n"
@ -1824,7 +1824,7 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pb, gsi::arg ("b"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pb, gsi::arg ("b"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of the polygon and a box\n"
"\n"
"@param b The box.\n"
@ -1834,7 +1834,7 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
"\n"
"This method was introduced in version 0.22.\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pc, gsi::arg ("b"), gsi::arg ("resolve_holes"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pc, gsi::arg ("b"), gsi::arg ("resolve_holes"),
"@brief Computes the Minkowski sum of the polygon and a contour of points (a trace)\n"
"\n"
"@param b The contour (a series of points forming the trace).\n"

24
src/db/db/gsiDeclDbRegion.cc
View File

@ -223,24 +223,24 @@ static void insert_si2 (db::Region *r, db::RecursiveShapeIterator si, db::ICplxT
}
}
static db::Region minkowsky_sum_pe (const db::Region *r, const db::Edge &e)
static db::Region minkowski_sum_pe (const db::Region *r, const db::Edge &e)
{
return r->processed (db::minkowsky_sum_computation<db::Edge> (e));
return r->processed (db::minkowski_sum_computation<db::Edge> (e));
}
static db::Region minkowsky_sum_pp (const db::Region *r, const db::Polygon &q)
static db::Region minkowski_sum_pp (const db::Region *r, const db::Polygon &q)
{
return r->processed (db::minkowsky_sum_computation<db::Polygon> (q));
return r->processed (db::minkowski_sum_computation<db::Polygon> (q));
}
static db::Region minkowsky_sum_pb (const db::Region *r, const db::Box &q)
static db::Region minkowski_sum_pb (const db::Region *r, const db::Box &q)
{
return r->processed (db::minkowsky_sum_computation<db::Box> (q));
return r->processed (db::minkowski_sum_computation<db::Box> (q));
}
static db::Region minkowsky_sum_pc (const db::Region *r, const std::vector<db::Point> &q)
static db::Region minkowski_sum_pc (const db::Region *r, const std::vector<db::Point> &q)
{
return r->processed (db::minkowsky_sum_computation<std::vector<db::Point> > (q));
return r->processed (db::minkowski_sum_computation<std::vector<db::Point> > (q));
}
static db::Region &move_p (db::Region *r, const db::Vector &p)
@ -2237,7 +2237,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"\n"
"This method has been introduced in version 0.26."
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pe, gsi::arg ("e"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pe, gsi::arg ("e"),
"@brief Compute the Minkowski sum of the region and an edge\n"
"\n"
"@param e The edge.\n"
@ -2251,7 +2251,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"The resulting polygons are not merged. In order to remove overlaps, use the \\merge or \\merged method."
"Merged semantics applies for the input of this method (see \\merged_semantics= for a description of this concept)\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pp, gsi::arg ("p"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pp, gsi::arg ("p"),
"@brief Compute the Minkowski sum of the region and a polygon\n"
"\n"
"@param p The first argument.\n"
@ -2264,7 +2264,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"The resulting polygons are not merged. In order to remove overlaps, use the \\merge or \\merged method."
"Merged semantics applies for the input of this method (see \\merged_semantics= for a description of this concept)\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pb, gsi::arg ("b"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pb, gsi::arg ("b"),
"@brief Compute the Minkowski sum of the region and a box\n"
"\n"
"@param b The box.\n"
@ -2277,7 +2277,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"The resulting polygons are not merged. In order to remove overlaps, use the \\merge or \\merged method."
"Merged semantics applies for the input of this method (see \\merged_semantics= for a description of this concept)\n"
) +
method_ext ("minkowsky_sum", &minkowsky_sum_pc, gsi::arg ("b"),
method_ext ("minkowski_sum|#minkowsky_sum", &minkowski_sum_pc, gsi::arg ("b"),
"@brief Compute the Minkowski sum of the region and a contour of points (a trace)\n"
"\n"
"@param b The contour (a series of points forming the trace).\n"

4
src/db/unit_tests/dbDeepRegionTests.cc
View File

@ -1279,8 +1279,8 @@ TEST(21_Processors)
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (25, 0)), r1.processed (db::RelativeExtentsAsEdges (0.5, 0.5, 0.5, 0.5)));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (26, 0)), r1.processed (db::RelativeExtentsAsEdges (0.25, 0.4, 0.75, 0.6)));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (30, 0)), r1.processed (db::minkowsky_sum_computation<db::Box> (db::Box (-1000, -2000, 3000, 4000))));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (31, 0)), r1.processed (db::minkowsky_sum_computation<db::Edge> (db::Edge (-1000, 0, 3000, 0))));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (30, 0)), r1.processed (db::minkowski_sum_computation<db::Box> (db::Box (-1000, -2000, 3000, 4000))));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (31, 0)), r1.processed (db::minkowski_sum_computation<db::Edge> (db::Edge (-1000, 0, 3000, 0))));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (40, 0)), r1.processed (db::TrapezoidDecomposition (db::TD_htrapezoids)));
target.insert (target_top_cell_index, target.get_layer (db::LayerProperties (41, 0)), r1.processed (db::ConvexDecomposition (db::PO_vertical)));

28
src/db/unit_tests/dbPolygonToolsTests.cc
View File

@ -1094,27 +1094,27 @@ TEST(41)
db::Polygon p;
p.assign_hull (&pattern[0], &pattern[0] + sizeof (pattern) / sizeof (pattern[0]));
db::Polygon pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (210, 110)), true);
db::Polygon pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (210, 110)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-40;-90,-65;10,110;210,210;260,160;310,185;310,60)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (10, 110)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (10, 110)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-40;-90,-65;-90,35;10,210;60,160;110,185;110,-40)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 110), db::Point (10, 10)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 110), db::Point (10, 10)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-40;-90,-65;-90,35;10,210;60,160;110,185;110,-40)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (210, 10)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (210, 10)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;10,110;210,110;235,85;310,85;310,-40;210,-90)");
pout = minkowsky_sum (p, db::Edge (db::Point (210, 10), db::Point (10, 10)), true);
pout = minkowski_sum (p, db::Edge (db::Point (210, 10), db::Point (10, 10)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;10,110;210,110;235,85;310,85;310,-40;210,-90)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (210, -90)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (210, -90)), true);
EXPECT_EQ (pout.to_string (), "(210,-190;143,-157;110,-165;-90,-65;10,110;85,72;110,85;310,-15;310,-140)");
@ -1125,7 +1125,7 @@ TEST(41)
c.push_back (db::Point (210, 10));
c.push_back (db::Point (10, 10));
pout = minkowsky_sum (p, c, true);
pout = minkowski_sum (p, c, true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;-90,35;10,210;210,210;235,185;310,185;310,-40;210,-90)");
@ -1136,7 +1136,7 @@ TEST(41)
c.push_back (db::Point (510, 10));
c.push_back (db::Point (10, 10));
pout = minkowsky_sum (p, c, true);
pout = minkowski_sum (p, c, true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;-90,210;110,210;110,110;410,110;410,210;-90,210;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
@ -1144,7 +1144,7 @@ TEST(41)
EXPECT_EQ (db::resolve_holes (pout).to_string (), "(10,-90;10,-65;-90,-65;-90,210;110,210;110,110;410,110;410,210;-90,210;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
EXPECT_EQ (db::polygon_to_simple_polygon (pout).to_string (), "(10,-90;10,-65;-90,-65;-90,210;110,210;110,110;410,110;410,210;-90,210;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
pout = minkowsky_sum (p, c, false);
pout = minkowski_sum (p, c, false);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90/110,110;410,110;410,210;110,210)");
@ -1153,11 +1153,11 @@ TEST(41)
EXPECT_EQ (db::polygon_to_simple_polygon (pout).to_string (), "(10,-90;10,-65;-90,-65;-90,210;110,210;110,110;410,110;410,210;-90,210;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
EXPECT_EQ (db::simple_polygon_to_polygon (db::polygon_to_simple_polygon (pout)).to_string (), "(10,-90;10,-65;-90,-65;-90,210;110,210;110,110;410,110;410,210;-90,210;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
pout = minkowsky_sum (p, db::Box (db::Point (10, 10), db::Point (210, 110)), true);
pout = minkowski_sum (p, db::Box (db::Point (10, 10), db::Point (210, 110)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;-90,35;10,210;210,210;235,185;310,185;310,-40;210,-90)");
pout = minkowsky_sum (p, db::Box (db::Point (10, 10), db::Point (510, 310)), false);
pout = minkowski_sum (p, db::Box (db::Point (10, 10), db::Point (510, 310)), false);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-65;-90,-65;-90,235;10,410;510,410;535,385;610,385;610,-40;510,-90)");
}
@ -1191,15 +1191,15 @@ TEST(42)
p.insert_hole (&hole[0], &hole[0] + sizeof (hole) / sizeof (hole[0]));
db::Polygon pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (30, 10)), true);
db::Polygon pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (30, 10)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-45;-70,-65;-90,-65;-15,65;27,65;-27,-29;25,-16;45,-16;50,-20;50,-47;90,-27;90,43;76,36;56,36;27,65;-15,65;-8,78;10,110;30,110;73,67;110,85;130,85;130,-40;30,-90)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (110, 110)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (110, 110)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-40;-90,-65;-8,78;10,110;110,210;160,160;210,185;210,60;110,-40)");
pout = minkowsky_sum (p, db::Edge (db::Point (10, 10), db::Point (50, 10)), true);
pout = minkowski_sum (p, db::Edge (db::Point (10, 10), db::Point (50, 10)), true);
EXPECT_EQ (pout.to_string (), "(10,-90;10,-50;-50,-65;-90,-65;-23,52;40,52;-3,-23;25,-16;65,-16;70,-20;70,-37;90,-27;90,36;56,36;40,52;-23,52;-8,78;10,110;50,110;87,73;110,85;150,85;150,-40;50,-90)");
}

4
src/db/unit_tests/dbRegionTests.cc
View File

@ -2044,8 +2044,8 @@ TEST(100_Processors)
EXPECT_EQ (db::compare (r.processed (db::RelativeExtentsAsEdges (0.5, 0.5, 0.5, 0.5)), "(50,100;50,100);(100,400;100,400)"), true);
EXPECT_EQ (db::compare (r.processed (db::RelativeExtentsAsEdges (0.25, 0.4, 0.75, 0.6)), "(25,80;75,120);(50,380;150,420)"), true);
EXPECT_EQ (db::compare (r.processed (db::minkowsky_sum_computation<db::Box> (db::Box (-10, -20, 30, 40))), "(-10,-20;-10,240;130,240;130,-20);(-10,280;-10,440;90,440;90,540;230,540;230,280)"), true);
EXPECT_EQ (db::compare (r.processed (db::minkowsky_sum_computation<db::Edge> (db::Edge (-10, 0, 30, 0))), "(-10,0;-10,200;130,200;130,0);(-10,300;-10,400;90,400;90,500;230,500;230,300)"), true);
EXPECT_EQ (db::compare (r.processed (db::minkowski_sum_computation<db::Box> (db::Box (-10, -20, 30, 40))), "(-10,-20;-10,240;130,240;130,-20);(-10,280;-10,440;90,440;90,540;230,540;230,280)"), true);
EXPECT_EQ (db::compare (r.processed (db::minkowski_sum_computation<db::Edge> (db::Edge (-10, 0, 30, 0))), "(-10,0;-10,200;130,200;130,0);(-10,300;-10,400;90,400;90,500;230,500;230,300)"), true);
EXPECT_EQ (db::compare (r.processed (db::TrapezoidDecomposition (db::TD_htrapezoids)), "(0,0;0,200;100,200;100,0);(100,300;100,500;200,500;200,300);(0,300;0,400;100,400;100,300)"), true);
EXPECT_EQ (r.processed (db::ConvexDecomposition (db::PO_vertical)).to_string (), "(0,0;0,200;100,200;100,0);(100,300;100,500;200,500;200,300);(0,300;0,400;100,400;100,300)");

6
src/lay/lay/doc/programming/geometry_api.xml
View File

@ -198,8 +198,8 @@ box = RBA::Box::new(dbox)
<p>
<class_doc href="SimplePolygon#compress"/> will remove points that connect two collinear edges. It has a parameter that controls whether to remove
reflecting edges (spikes) as well. <class_doc href="SimplePolygon#inside?"/> returns true, if a given point is inside the polygon. <class_doc href="SimplePolygon#minkowsky_sum"/>
computes the Minkowsky sum between a polygon and another object in various flavors. <class_doc href="SimplePolygon#move"/> will displace the polygon
reflecting edges (spikes) as well. <class_doc href="SimplePolygon#inside?"/> returns true, if a given point is inside the polygon. <class_doc href="SimplePolygon#minkowski_sum"/>
computes the Minkowski sum between a polygon and another object in various flavors. <class_doc href="SimplePolygon#move"/> will displace the polygon
by the distance given by the Point argument. <class_doc href="SimplePolygon#moved"/> will return the moved polygon without modifying the
polygon it is called on (out-of-place operation). <class_doc href="SimplePolygon#transformed"/> will return the
transformed polygon, either with a simple or a complex transformation (see the description of the Box object and the
@ -652,7 +652,7 @@ ly.top_cell.shapes(ly.layer(100, 0)).insert(r11 &amp; r21)
way in another region.</p>
<p><class_doc href="Region#merge"/> and <class_doc href="Region#merged"/> merge the polygons. This feature allows selecting overlapping polygons
(minimum wrap count parameter).</p>
<p><class_doc href="Region#minkowsky_sum"/> computes the Minkowsky sum of the region with other objects (edges, single polygons and other regions).</p>
<p><class_doc href="Region#minkowski_sum"/> computes the Minkowski sum of the region with other objects (edges, single polygons and other regions).</p>
<p><class_doc href="Region#move"/>, <class_doc href="Region#moved"/>, <class_doc href="Region#transform"/> and
<class_doc href="Region#transformed"/> apply geometrical transformations.</p>
<p><class_doc href="Region#rectangles"/>, <class_doc href="Region#rectilinear"/>, <class_doc href="Region#non_rectangles"/> and

4
src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc
View File

@ -423,7 +423,7 @@ DEFImporter::produce_routing_geometry (db::Cell &design, const Polygon *style, u
db::Polygon k;
k.assign_hull (octagon, octagon + sizeof (octagon) / sizeof (octagon[0]));
db::Polygon p = db::minkowsky_sum (k, db::Edge (*pt0, *pt));
db::Polygon p = db::minkowski_sum (k, db::Edge (*pt0, *pt));
if (prop_id != 0) {
design.shapes (layer).insert (db::object_with_properties<db::Polygon> (p, prop_id));
} else {
@ -439,7 +439,7 @@ DEFImporter::produce_routing_geometry (db::Cell &design, const Polygon *style, u
} else {
for (size_t i = 0; i < pts.size () - 1; ++i) {
db::Polygon p = db::minkowsky_sum (*style, db::Edge (pts [i], pts [i + 1]));
db::Polygon p = db::minkowski_sum (*style, db::Edge (pts [i], pts [i + 1]));
if (prop_id != 0) {
design.shapes (layer).insert (db::object_with_properties<db::Polygon> (p, prop_id));
} else {

4
src/plugins/streamers/pcb/db_plugin/dbRS274XApertures.cc
View File

@ -93,7 +93,7 @@ RS274XApertureBase::produce_linear (const db::DCplxTrans &d, const db::DVector &
if (! do_produce_linear (from, to)) {
// fallback: produce flash and employ a Minkowsky sum to generate the resulting structure
// fallback: produce flash and employ a Minkowski sum to generate the resulting structure
do_produce_flash ();
double dbu = mp_reader->dbu ();
@ -111,7 +111,7 @@ RS274XApertureBase::produce_linear (const db::DCplxTrans &d, const db::DVector &
}
for (std::vector<db::Polygon>::const_iterator f = p.begin (); f != p.end (); ++f) {
m_polygons.push_back (db::minkowsky_sum (*f, db::Edge (ifrom, ito), true /*resolve holes*/));
m_polygons.push_back (db::minkowski_sum (*f, db::Edge (ifrom, ito), true /*resolve holes*/));
}
}