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

src/db/db/dbPolygonTools.cc

@@ -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);
   }
 }
 

src/db/db/dbPolygonTools.h

@@ -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 

src/db/db/dbRegionProcessors.h

@@ -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

src/db/db/gsiDeclDbCompoundOperation.cc

@@ -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),

src/db/db/gsiDeclDbPolygon.cc

@@ -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"

src/db/db/gsiDeclDbRegion.cc

@@ -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"

src/db/unit_tests/dbDeepRegionTests.cc

@@ -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 (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::minkowsky_sum_computation<db::Edge> (db::Edge (-1000, 0, 3000, 0))));
+  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)));

src/db/unit_tests/dbPolygonToolsTests.cc

@@ -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)");
 }

src/db/unit_tests/dbRegionTests.cc

@@ -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::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::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::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)");

src/lay/lay/doc/programming/geometry_api.xml

@@ -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"/>
+  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 Minkowsky sum between a polygon and another object in various flavors. <class_doc href="SimplePolygon#move"/> will displace the polygon
+  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

src/plugins/streamers/lefdef/db_plugin/dbDEFImporter.cc

@@ -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 {

src/plugins/streamers/pcb/db_plugin/dbRS274XApertures.cc

@@ -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*/));
     }
     
   }