mirror of https://github.com/KLayout/klayout.git
Fix misspellings in db.
This commit is contained in:
parent
f956dd478b
commit
ed27447ce0
|
|
@ -1982,7 +1982,7 @@ struct array
|
|||
* The raw bounding boxes can be accumulated for all arrays having the same
|
||||
* orientation, magnification and object.
|
||||
* bbox_from_raw_bbox can be used to compute the total bbox from such an
|
||||
* accumulated raw bounding box. This is for example exploitet in the
|
||||
* accumulated raw bounding box. This is for example exploited in the
|
||||
* update_bbox method of db::cell.
|
||||
*/
|
||||
box_type raw_bbox () const
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ struct DB_PUBLIC_TEMPLATE box
|
|||
*
|
||||
* As the four coordinate constructor but accepting two
|
||||
* point objects. The coordinates are sorted so the points
|
||||
* do not neccessarily need to be lower/left or upper/right.
|
||||
* do not necessarily need to be lower/left or upper/right.
|
||||
*
|
||||
* @param p1 The first point
|
||||
* @param p2 The second point
|
||||
|
|
@ -337,7 +337,7 @@ struct DB_PUBLIC_TEMPLATE box
|
|||
/**
|
||||
* @brief Reduce the box
|
||||
*
|
||||
* This method is mainly provided for template argument substituition
|
||||
* This method is mainly provided for template argument substitution
|
||||
* of path and polygon objects by boxes. It basically moves the box.
|
||||
*
|
||||
* @param tr Receives the transformation that must be applied to render the original box
|
||||
|
|
@ -352,7 +352,7 @@ struct DB_PUBLIC_TEMPLATE box
|
|||
/**
|
||||
* @brief Reduce the box
|
||||
*
|
||||
* This method is mainly provided for template argument substituition
|
||||
* This method is mainly provided for template argument substitution
|
||||
* of path and polygon objects by boxes. It basically moves the box.
|
||||
*
|
||||
* @param tr Receives the transformation that must be applied to render the original box
|
||||
|
|
@ -367,7 +367,7 @@ struct DB_PUBLIC_TEMPLATE box
|
|||
/**
|
||||
* @brief Reduce the box
|
||||
*
|
||||
* This method is mainly provided for template argument substituition
|
||||
* This method is mainly provided for template argument substitution
|
||||
* of path and polygon objects by boxes. It basically does nothing (like the same methods in path etc.)
|
||||
*/
|
||||
void reduce (unit_trans<coord_type> &)
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ private:
|
|||
|
||||
|
||||
/// @brief a helper class providing a linear-time iterator difference which is not necessarily
|
||||
/// the actual difference but monotoneous
|
||||
/// the actual difference but monotonous
|
||||
|
||||
template <class X>
|
||||
size_t box_tree_lt_difference (const tl::reuse_vector_const_iterator<X> &a, const tl::reuse_vector_const_iterator<X> &b)
|
||||
|
|
@ -329,7 +329,7 @@ private:
|
|||
* Unlike the primitive iterator, which is based on the container inside
|
||||
* the box tree, this iterator iterates "registered" elements, i.e. such that
|
||||
* are within the sorted list. Since this list is maintained even if elements
|
||||
* are insered, this iterator is less susceptible to changes in the container,
|
||||
* are inserted, this iterator is less susceptible to changes in the container,
|
||||
* i.e. by inserting or deleting elements while iterating.
|
||||
* This iterator is therefore recommended for being used in interleaved access/change
|
||||
* operations.
|
||||
|
|
@ -842,7 +842,7 @@ public:
|
|||
/**
|
||||
* @brief Insert a range of objects
|
||||
*
|
||||
* Analogeous to the other insert method, but accepting
|
||||
* Analogous to the other insert method, but accepting
|
||||
* and range of objects [start,end).
|
||||
*/
|
||||
template <class I>
|
||||
|
|
@ -1357,7 +1357,7 @@ inline void mem_stat (MemStatistics *stat, MemStatistics::purpose_t purpose, int
|
|||
* Unlike the primitive iterator, which is based on the container inside
|
||||
* the box tree, this iterator iterates "registered" elements, i.e. such that
|
||||
* are within the sorted list. Since this list is maintained even if elements
|
||||
* are insered, this iterator is less susceptible to changes in the container,
|
||||
* are inserted, this iterator is less susceptible to changes in the container,
|
||||
* i.e. by inserting or deleting elements while iterating.
|
||||
* This iterator is therefore recommended for being used in interleaved access/change
|
||||
* operations.
|
||||
|
|
@ -1834,7 +1834,7 @@ public:
|
|||
/**
|
||||
* @brief Insert a range of objects
|
||||
*
|
||||
* Analogeous to the other insert method, but accepting
|
||||
* Analogous to the other insert method, but accepting
|
||||
* and range of objects [start,end).
|
||||
*/
|
||||
template <class I>
|
||||
|
|
|
|||
|
|
@ -489,7 +489,7 @@ public:
|
|||
* This requires the bboxes of the child cells to be computed
|
||||
* before. Practically this will be done by computing the
|
||||
* bboxes bottom-up in the hierarchy.
|
||||
* In addition, the number of hierarchy leves below is also
|
||||
* In addition, the number of hierarchy levels below is also
|
||||
* updated.
|
||||
*
|
||||
* @param layers The max. number of layers in the child cells
|
||||
|
|
@ -958,8 +958,8 @@ public:
|
|||
*
|
||||
* If the source and target layout are different ones, the whole cell tree of the source cell
|
||||
* will be copied.
|
||||
* This will create new cells in the target layout to accomodate the source cell tree.
|
||||
* Returns an array with the freshly created cells which acommodate the cell tree.
|
||||
* This will create new cells in the target layout to accommodate the source cell tree.
|
||||
* Returns an array with the freshly created cells which accommodate the cell tree.
|
||||
*/
|
||||
std::vector<db::cell_index_type> copy_tree (const db::Cell &source_cell);
|
||||
|
||||
|
|
@ -997,8 +997,8 @@ public:
|
|||
*
|
||||
* If the source and target layout are different ones, the whole cell tree of the source cell
|
||||
* will be copied.
|
||||
* This will create new cells in the target layout to accomodate the source cell tree.
|
||||
* Returns an array with the freshly created cells which acommodate the cell tree.
|
||||
* This will create new cells in the target layout to accommodate the source cell tree.
|
||||
* Returns an array with the freshly created cells which accommodate the cell tree.
|
||||
*/
|
||||
std::vector<db::cell_index_type> move_tree (db::Cell &source_cell);
|
||||
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ public:
|
|||
* @brief Determine the instance count of the cell with index "ci"
|
||||
*
|
||||
* The instance count is the number of "flat" instances of the cell in all
|
||||
* top cells of the graph. A top cell has a multiplicty of 1.
|
||||
* top cells of the graph. A top cell has a multiplicity of 1.
|
||||
*/
|
||||
size_t weight (db::cell_index_type ci);
|
||||
|
||||
|
|
|
|||
|
|
@ -457,7 +457,7 @@ CellMapping::create_from_geometry (const db::Layout &layout_a, db::cell_index_ty
|
|||
for (std::multimap<size_t, db::cell_index_type>::const_iterator bb = b; bb != cm_b.end () && bb->first == w; ++bb) {
|
||||
++nb;
|
||||
}
|
||||
tl::info << "Multiplity group (" << w << " instances) - " << na << " vs. " << nb << " cells";
|
||||
tl::info << "Multiplicity group (" << w << " instances) - " << na << " vs. " << nb << " cells";
|
||||
}
|
||||
|
||||
unsigned int g = 0;
|
||||
|
|
|
|||
|
|
@ -164,7 +164,7 @@ public:
|
|||
db::cell_index_type make_cell (db::Layout &layout, size_t id);
|
||||
|
||||
/**
|
||||
* @brief Returns true, if there is a cell with the given ID alreay
|
||||
* @brief Returns true, if there is a cell with the given ID already
|
||||
*/
|
||||
bool has_cell (size_t id) const;
|
||||
|
||||
|
|
|
|||
|
|
@ -1450,7 +1450,7 @@ DeepEdges::selected_interacting_generic (const Region &other, bool inverse) cons
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1476,7 +1476,7 @@ DeepEdges::selected_interacting_generic (const Edges &other, bool inverse) const
|
|||
std::unique_ptr<db::DeepEdges> dr_holder;
|
||||
const db::DeepEdges *other_deep = dynamic_cast<const db::DeepEdges *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other edge collection isn't deep, turn into a top-level only deep edge collection to facilitate re-hierarchisation
|
||||
// if the other edge collection isn't deep, turn into a top-level only deep edge collection to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepEdges (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1501,7 +1501,7 @@ RegionDelegate *DeepEdges::pull_generic (const Region &other) const
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1527,7 +1527,7 @@ EdgesDelegate *DeepEdges::pull_generic (const Edges &other) const
|
|||
std::unique_ptr<db::DeepEdges> dr_holder;
|
||||
const db::DeepEdges *other_deep = dynamic_cast<const db::DeepEdges *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other edge collection isn't deep, turn into a top-level only deep edge collection to facilitate re-hierarchisation
|
||||
// if the other edge collection isn't deep, turn into a top-level only deep edge collection to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepEdges (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1804,7 +1804,7 @@ DeepRegion::selected_interacting_generic (const Region &other, int mode, bool to
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1844,7 +1844,7 @@ DeepRegion::selected_interacting_generic (const Edges &other, InteractingOutputM
|
|||
std::unique_ptr<db::DeepEdges> dr_holder;
|
||||
const db::DeepEdges *other_deep = dynamic_cast<const db::DeepEdges *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepEdges (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1880,7 +1880,7 @@ DeepRegion::pull_generic (const Region &other, int mode, bool touching) const
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1918,7 +1918,7 @@ DeepRegion::pull_generic (const Edges &other) const
|
|||
std::unique_ptr<db::DeepEdges> dr_holder;
|
||||
const db::DeepEdges *other_deep = dynamic_cast<const db::DeepEdges *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepEdges (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1949,7 +1949,7 @@ DeepRegion::pull_generic (const Texts &other) const
|
|||
std::unique_ptr<db::DeepTexts> dr_holder;
|
||||
const db::DeepTexts *other_deep = dynamic_cast<const db::DeepTexts *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepTexts (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -1984,7 +1984,7 @@ DeepRegion::selected_interacting_generic (const Texts &other, InteractingOutputM
|
|||
std::unique_ptr<db::DeepTexts> dr_holder;
|
||||
const db::DeepTexts *other_deep = dynamic_cast<const db::DeepTexts *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepTexts (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -299,7 +299,7 @@ struct DB_PUBLIC RecursiveShapeIteratorCompareForTargetHierarchy
|
|||
* for the actual shapes.
|
||||
*
|
||||
* The deep shape store provides the basis for working with deep regions. On preparation,
|
||||
* shapes are copied into the deep shape store. After fininishing, the shapes are copied
|
||||
* shapes are copied into the deep shape store. After finishing, the shapes are copied
|
||||
* back into the original layout. The deep shape store provides the methods and
|
||||
* algorithms for doing the preparation and transfer.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -697,7 +697,7 @@ DeepTexts::selected_interacting_generic (const Region &other, bool inverse) cons
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
@ -722,7 +722,7 @@ RegionDelegate *DeepTexts::pull_generic (const Region &other) const
|
|||
std::unique_ptr<db::DeepRegion> dr_holder;
|
||||
const db::DeepRegion *other_deep = dynamic_cast<const db::DeepRegion *> (other.delegate ());
|
||||
if (! other_deep) {
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchisation
|
||||
// if the other region isn't deep, turn into a top-level only deep region to facilitate re-hierarchization
|
||||
dr_holder.reset (new db::DeepRegion (other, const_cast<db::DeepShapeStore &> (*deep_layer ().store ())));
|
||||
other_deep = dr_holder.get ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -609,7 +609,7 @@ public:
|
|||
/**
|
||||
* @brief Registers a compare delegate
|
||||
*
|
||||
* The reasoning behind chosing a delegate is that a delegate is efficient
|
||||
* The reasoning behind choosing a delegate is that a delegate is efficient
|
||||
* also in scripts if one of the standard delegates is taken.
|
||||
*
|
||||
* The device class takes ownership of the delegate.
|
||||
|
|
|
|||
|
|
@ -869,7 +869,7 @@ public:
|
|||
// d = (a x b) / sqrt (a * a)
|
||||
// where b = p - p1, a = p2 - p1
|
||||
if (is_degenerate ()) {
|
||||
// for safty handle this case - without a reasonable result
|
||||
// for safety handle this case - without a reasonable result
|
||||
return 0;
|
||||
} else {
|
||||
// compute the distance as described above
|
||||
|
|
@ -917,7 +917,7 @@ public:
|
|||
// d = (a x b) / sqrt (a * a)
|
||||
// where b = p - p1, a = p2 - p1
|
||||
if (is_degenerate ()) {
|
||||
// for safty handle this case - without a reasonable result
|
||||
// for safety handle this case - without a reasonable result
|
||||
return 0;
|
||||
} else {
|
||||
// compute the side as the sign of the distance as in "distance"
|
||||
|
|
@ -940,7 +940,7 @@ public:
|
|||
// d = (a x b) / sqrt (a * a)
|
||||
// where b = p - p1, a = p2 - p1
|
||||
if (is_degenerate ()) {
|
||||
// for safty handle this case - without a reasonable result
|
||||
// for safety handle this case - without a reasonable result
|
||||
return 0;
|
||||
} else {
|
||||
// compute the distance as described above
|
||||
|
|
@ -1459,7 +1459,7 @@ inline C edge_xmax_at_yinterval (const db::edge<C> &e, C y1, C y2)
|
|||
/**
|
||||
* @brief Functor that compares two edges by their left bound for a given interval [y1..y2].
|
||||
*
|
||||
* This function is intended for use in scanline scenarious to determine what edges are
|
||||
* This function is intended for use in scanline scenarios to determine what edges are
|
||||
* interacting in a certain y interval.
|
||||
*/
|
||||
template <class C>
|
||||
|
|
|
|||
|
|
@ -712,7 +712,7 @@ InteractionDetector::edge (bool north, bool enter, property_type p)
|
|||
for (std::set <property_type>::const_iterator i = inside->begin (); i != inside->end (); ++i) {
|
||||
if (*i > m_last_primary_id) {
|
||||
if (m_mode < -1) {
|
||||
// enclosing mode: an opening primary (= enclosing one) whith open secondaries means the secondary
|
||||
// enclosing mode: an opening primary (= enclosing one) with open secondaries means the secondary
|
||||
// has been opened before and did not close. Because we sort by property ID this must have happened
|
||||
// before, hence the secondary is overlapping. Make them non-interactions. We still have to record them
|
||||
// as interactions because this is how we skip the primaries later.
|
||||
|
|
@ -1297,7 +1297,7 @@ inline C edge_xmax_at_yinterval_double (const db::edge<C> &e, double y1, double
|
|||
/**
|
||||
* @brief Functor that compares two edges by their left bound for a given interval [y1..y2].
|
||||
*
|
||||
* This function is intended for use in scanline scenarious to determine what edges are
|
||||
* This function is intended for use in scanline scenarios to determine what edges are
|
||||
* interacting in a certain y interval.
|
||||
*/
|
||||
template <class C>
|
||||
|
|
@ -1764,7 +1764,7 @@ public:
|
|||
/**
|
||||
* @brief A structure holding the "skip information"
|
||||
*
|
||||
* Skipping intervals with a known behavior is an optimization to improvee
|
||||
* Skipping intervals with a known behavior is an optimization to improve
|
||||
* the scanner's performance. This object keeps the information required to
|
||||
* properly implement the skipping. It keeps both the edge skip count per
|
||||
* interval ("skip") as well as the corresponding skip count for the
|
||||
|
|
@ -2451,7 +2451,7 @@ EdgeProcessor::process (const std::vector<std::pair<db::EdgeSink *, db::EdgeEval
|
|||
++f;
|
||||
}
|
||||
|
||||
// compute edges that occure at this vertex
|
||||
// compute edges that occur at this vertex
|
||||
|
||||
gs.next_vertex (x);
|
||||
|
||||
|
|
@ -2517,7 +2517,7 @@ EdgeProcessor::process (const std::vector<std::pair<db::EdgeSink *, db::EdgeEval
|
|||
|
||||
// report the closing or opening edges in the opposite order
|
||||
// than the other ones (see previous loop). Hence we have some
|
||||
// symmetry of events which simplify implementatin of the
|
||||
// symmetry of events which simplify implementation of the
|
||||
// InteractionDetector for example.
|
||||
do {
|
||||
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ public:
|
|||
/**
|
||||
* @brief Deliver an edge set forming a closed sequence
|
||||
*
|
||||
* See description of "crossing_egde" for details.
|
||||
* See description of "crossing_edge" for details.
|
||||
*/
|
||||
virtual void skip_n (size_t /*n*/) { }
|
||||
|
||||
|
|
@ -843,7 +843,7 @@ public:
|
|||
*
|
||||
* This method sizes a set of polygons. Before the sizing is applied, the polygons are merged. After that, sizing is applied
|
||||
* on the individual result polygons of the merge step. The result may contain overlapping polygons, but no self-overlapping ones.
|
||||
* Polygon overlap occures if the polygons are close enough, so a positive sizing makes polygons overlap.
|
||||
* Polygon overlap occurs if the polygons are close enough, so a positive sizing makes polygons overlap.
|
||||
*
|
||||
* dx and dy describe the sizing. A positive value indicates oversize (outwards) while a negative one describes undersize (inwards).
|
||||
* The sizing applied can be chosen differently in x and y direction. In this case, the sign must be identical for both
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ class Region;
|
|||
*
|
||||
* p(i,j) = p0 + i * row_step + j * column_step
|
||||
*
|
||||
* p0 is a position chosen by the fill alogorithm or the "origin", if enhanced_fill is false.
|
||||
* p0 is a position chosen by the fill algorithm or the "origin", if enhanced_fill is false.
|
||||
*
|
||||
* This pattern is overlaid with the polygon to fill and all instances where the fill box moved by p(i,j) is entirely inside
|
||||
* the polygon generate a fill cell instance with a displacement of p.
|
||||
|
|
@ -108,7 +108,7 @@ fill_region (db::Cell *cell, const db::Region &fp, db::cell_index_type fill_cell
|
|||
/**
|
||||
* @brief An iterative version for enhanced fill
|
||||
*
|
||||
* This version operates like the region-based fill_region version, but repeates the fill step until no further fill cells can be placed.
|
||||
* This version operates like the region-based fill_region version, but repeats the fill step until no further fill cells can be placed.
|
||||
* The remaining parts will be placed inside "remaining_polygons" unless this pointer is null.
|
||||
*
|
||||
* This version implies enhanced_mode (see "fill_region").
|
||||
|
|
|
|||
|
|
@ -368,7 +368,7 @@ public:
|
|||
* @brief A helper class allowing delivery of addressable edges
|
||||
*
|
||||
* In some applications (i.e. box scanner), shapes need to be taken
|
||||
* by address. An iterator cannot always deliver adressable objects.
|
||||
* by address. An iterator cannot always deliver addressable objects.
|
||||
* This class help providing this ability by keeping a temporary copy
|
||||
* if required.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ public:
|
|||
|
||||
/**
|
||||
* @brief Returns the font with the given name
|
||||
* If no font with that name exsist, 0 is returned.
|
||||
* If no font with that name exists, 0 is returned.
|
||||
*/
|
||||
static const TextGenerator *generator_by_name (const std::string &name);
|
||||
|
||||
|
|
|
|||
|
|
@ -1406,7 +1406,7 @@ namespace
|
|||
*
|
||||
* This receiver is both used for the instance-to-instance and the local-to-instance
|
||||
* interactions. It is employed on cell level for in two box scanners: one
|
||||
* investigating the instance-to-instance interactions and another one invesitating
|
||||
* investigating the instance-to-instance interactions and another one investigating
|
||||
* local cluster to instance interactions.
|
||||
*/
|
||||
template <class T>
|
||||
|
|
@ -1574,10 +1574,10 @@ private:
|
|||
*
|
||||
* @param common The common box of both instances
|
||||
* @param i1 The first instance to investigate
|
||||
* @param t1 The parent instances' culmulated transformation
|
||||
* @param t1 The parent instances' cumulated transformation
|
||||
* @param i1element selects a specific instance from i1 (unless == db::CellInstArray::iterator())
|
||||
* @param i2 The second instance to investiage
|
||||
* @param t2 The parent instances' culmulated transformation
|
||||
* @param i2 The second instance to investigate
|
||||
* @param t2 The parent instances' cumulated transformation
|
||||
* @param i2element selects a specific instance from i2 (unless == db::CellInstArray::iterator())
|
||||
* @param interacting_clusters_out Receives the cluster interaction descriptors
|
||||
*
|
||||
|
|
@ -1606,7 +1606,7 @@ private:
|
|||
return;
|
||||
}
|
||||
|
||||
// gross shortcut: the cells do no comprise a constallation which will ever interact
|
||||
// gross shortcut: the cells do no comprise a constellation which will ever interact
|
||||
if (! mp_conn->interact (mp_layout->cell (i1.cell_index ()), mp_layout->cell (i2.cell_index ()))) {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -215,7 +215,7 @@ private:
|
|||
* @brief Represents a cluster of shapes
|
||||
*
|
||||
* A cluster of shapes is a set of shapes of type T which are connected in terms
|
||||
* of a given connectivity. The shapes will still be organised in layers.
|
||||
* of a given connectivity. The shapes will still be organized in layers.
|
||||
*/
|
||||
template <class T>
|
||||
class DB_PUBLIC_TEMPLATE local_cluster
|
||||
|
|
|
|||
|
|
@ -548,7 +548,7 @@ local_processor_cell_contexts<TS, TI, TR>::compute_results (const local_processo
|
|||
int total = int (m_contexts.size ());
|
||||
|
||||
// NOTE: we use the ordering provided by key_type::operator< rather than the unordered map to achieve
|
||||
// reproducability across different platforms. unordered_map is faster, but for processing them,
|
||||
// reproducibility across different platforms. unordered_map is faster, but for processing them,
|
||||
// strict ordering is a more robust choice.
|
||||
std::vector<std::pair<const context_key_type *, db::local_processor_cell_context<TS, TI, TR> *> > sorted_contexts;
|
||||
sorted_contexts.reserve (m_contexts.size ());
|
||||
|
|
@ -1045,7 +1045,7 @@ instances_interact (const db::Layout *layout1, const db::CellInstArray *inst1, u
|
|||
|
||||
db::ICplxTrans tn2 = inst2->complex_trans (*k);
|
||||
|
||||
// NOTE: we need to enlarge both subject *and* intruder boxes - either ubject comes close to intruder or the other way around
|
||||
// NOTE: we need to enlarge both subject *and* intruder boxes - either object comes close to intruder or the other way around
|
||||
db::Box ibox2 = tn2 * cell2.bbox (layer2).enlarged (db::Vector (dist, dist));
|
||||
|
||||
db::ICplxTrans tn21 = tni1 * tn2;
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ InstOp<Inst, ET>::erase (Instances *insts)
|
|||
std::vector<bool> done;
|
||||
done.resize (m_insts.size (), false);
|
||||
|
||||
// This is not quite effective but seems to be the simpliest way
|
||||
// This is not quite effective but seems to be the simplest way
|
||||
// of implementing this: search for each element and erase these.
|
||||
// The alternative would be to store the iterator along with the object.
|
||||
std::vector<typename tree_type::const_iterator> to_erase;
|
||||
|
|
|
|||
|
|
@ -390,7 +390,7 @@ public:
|
|||
*
|
||||
* Ordering of instances is not specified by the identity of the objects but by the
|
||||
* order of the pointers.
|
||||
* Since pointers are volatile objects, the ordering is not strictly reproducable!
|
||||
* Since pointers are volatile objects, the ordering is not strictly reproducible!
|
||||
* The order is designed such that different types of instances are separated in
|
||||
* an order sequence of instance proxies. This is an important fact for the
|
||||
* "erase" functionality of the instances container when erasing a set of objects.
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ struct layer
|
|||
/**
|
||||
* @brief The assignment operator
|
||||
*
|
||||
* The manager attachement is not copied.
|
||||
* The manager attachment is not copied.
|
||||
*/
|
||||
layer &operator= (const layer &d)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1241,7 +1241,7 @@ Layout::take_cell (cell_index_type ci)
|
|||
// Using free cell indices does have one significant drawback:
|
||||
// The cellview references cannot be uniquely classified as being invalid - because the
|
||||
// ID might be reused. This causes problems, when a cell is being deleted and subsequently a
|
||||
// cell is being created - a crash occures. Therefore the free index feature is disabled.
|
||||
// cell is being created - a crash occurs. Therefore the free index feature is disabled.
|
||||
// If this causes memory consumption problems, it should be considered to use a map and
|
||||
// an arbitrary ID.
|
||||
// m_free_cell_indices.push_back (ci);
|
||||
|
|
|
|||
|
|
@ -539,7 +539,7 @@ public:
|
|||
* @brief The copy ctor
|
||||
*
|
||||
* This copy constructor inherits the attachment to a manager.
|
||||
* For copying without attachement, create a layout without a manager attached
|
||||
* For copying without attachment, create a layout without a manager attached
|
||||
* and use the assignment operator.
|
||||
*/
|
||||
Layout (const Layout &d);
|
||||
|
|
@ -1118,7 +1118,7 @@ public:
|
|||
/**
|
||||
* @brief Delete a cell plus the subcells not used otherwise
|
||||
*
|
||||
* All subcells referenced directy or indirectly but not used otherwise
|
||||
* All subcells referenced directly or indirectly but not used otherwise
|
||||
* are deleted as well. This basically prunes the cell tree by this cell.
|
||||
* All instances of this cell are deleted as well.
|
||||
*
|
||||
|
|
@ -1130,10 +1130,10 @@ public:
|
|||
/**
|
||||
* @brief Delete cells plus their subcells not used otherwise
|
||||
*
|
||||
* All subcells referenced directy or indirectly but not used otherwise
|
||||
* All subcells referenced directly or indirectly but not used otherwise
|
||||
* are deleted as well. This basically prunes the cell tree by this cell.
|
||||
* All instances of this cell are deleted as well.
|
||||
* This method is more efficent than calling prune_cell multiple times.
|
||||
* This method is more efficient than calling prune_cell multiple times.
|
||||
*
|
||||
* @param from A begin iterator delivering the cell id's to delete
|
||||
* @param to An end iterator delivering the cell id's to delete
|
||||
|
|
@ -1150,10 +1150,10 @@ public:
|
|||
/**
|
||||
* @brief Delete cells plus their subcells not used otherwise
|
||||
*
|
||||
* All subcells referenced directy or indirectly but not used otherwise
|
||||
* All subcells referenced directly or indirectly but not used otherwise
|
||||
* are deleted as well. This basically prunes the cell tree by this cell.
|
||||
* All instances of this cell are deleted as well.
|
||||
* This method is more efficent than calling prune_cell multiple times.
|
||||
* This method is more efficient than calling prune_cell multiple times.
|
||||
*
|
||||
* @param cells A set of cell id's to prune
|
||||
* @param levels The number of hierarchy levels to look for (-1: all, 0: none, 1: one level etc.)
|
||||
|
|
@ -1163,7 +1163,7 @@ public:
|
|||
/**
|
||||
* @brief Delete the subcells of the given cell which are not used otherwise
|
||||
*
|
||||
* All subcells of the given cell which are referenced directy or indirectly but not used otherwise
|
||||
* All subcells of the given cell which are referenced directly or indirectly but not used otherwise
|
||||
* are deleted.
|
||||
*
|
||||
* @param id The index whose subcells to delete
|
||||
|
|
@ -1174,9 +1174,9 @@ public:
|
|||
/**
|
||||
* @brief Delete the subcells of the given cells which are not used otherwise
|
||||
*
|
||||
* All subcells referenced directy or indirectly but not used otherwise
|
||||
* All subcells referenced directly or indirectly but not used otherwise
|
||||
* are deleted as well.
|
||||
* This method is more efficent than calling prune_subcells for single cells multiple times.
|
||||
* This method is more efficient than calling prune_subcells for single cells multiple times.
|
||||
*
|
||||
* @param from A begin iterator delivering the cell id's to delete
|
||||
* @param to An end iterator delivering the cell id's to delete
|
||||
|
|
@ -1193,9 +1193,9 @@ public:
|
|||
/**
|
||||
* @brief Delete the subcells of the given cells which are not used otherwise
|
||||
*
|
||||
* All subcells referenced directy or indirectly but not used otherwise
|
||||
* All subcells referenced directly or indirectly but not used otherwise
|
||||
* are deleted as well.
|
||||
* This method is more efficent than calling prune_subcells for single cells multiple times.
|
||||
* This method is more efficient than calling prune_subcells for single cells multiple times.
|
||||
*
|
||||
* @param cells A set of cell id's to prune
|
||||
* @param levels The number of hierarchy levels to look for (-1: all, 0: none, 1: one level etc.)
|
||||
|
|
@ -1262,7 +1262,7 @@ public:
|
|||
/**
|
||||
* @brief Delete a cell plus all subcells
|
||||
*
|
||||
* All subcells referenced directy or indirectly are deleted as well.
|
||||
* All subcells referenced directly or indirectly are deleted as well.
|
||||
* All instances of these cells are deleted as well.
|
||||
*
|
||||
* @param id The index of the cell to delete
|
||||
|
|
@ -1428,7 +1428,7 @@ public:
|
|||
* @brief Query the number of layers defined so far
|
||||
*
|
||||
* TODO: the list of 0 to nlayers-1 also contains the free layers -
|
||||
* we should get a vector containing the layers that are acually
|
||||
* we should get a vector containing the layers that are actually
|
||||
* allocated.
|
||||
*/
|
||||
unsigned int layers () const
|
||||
|
|
@ -1705,7 +1705,7 @@ public:
|
|||
* about to be brought into an invalid state. After calling
|
||||
* this method, "under_construction" returns false which
|
||||
* tells foreign code (such as update which might be called
|
||||
* asynchroneously for example because of a repaint event)
|
||||
* asynchronously for example because of a repaint event)
|
||||
* not to use this layout object.
|
||||
* This state is cancelled by the end_changes () method.
|
||||
* The start_changes () method can be called multiple times
|
||||
|
|
|
|||
|
|
@ -87,8 +87,8 @@ public:
|
|||
/**
|
||||
* @brief Create the state object for this filter
|
||||
*
|
||||
* This method must be implementated by a filter to provide the state object.
|
||||
* The state object is bascially the selector and acts as a iterator for the property that this
|
||||
* This method must be implemented by a filter to provide the state object.
|
||||
* The state object is basically the selector and acts as a iterator for the property that this
|
||||
* filter represents.
|
||||
* This method is provided for implementation by FilterBracket mainly.
|
||||
* Custom classes should implement do_create_state.
|
||||
|
|
@ -139,8 +139,8 @@ protected:
|
|||
/**
|
||||
* @brief Create the state object for this filter
|
||||
*
|
||||
* This method must be implementated by a filter to provide the state object.
|
||||
* The state object is bascially the selector and acts as a iterator for the property that this
|
||||
* This method must be implemented by a filter to provide the state object.
|
||||
* The state object is basically the selector and acts as a iterator for the property that this
|
||||
* filter represents.
|
||||
*
|
||||
* @param layout The layout that this query refers to.
|
||||
|
|
@ -170,7 +170,7 @@ private:
|
|||
/**
|
||||
* @brief A filter bracket
|
||||
*
|
||||
* A bracket is a bracket around a filter graph. In addition, brackets can specify a multiplity
|
||||
* A bracket is a bracket around a filter graph. In addition, brackets can specify a multiplicity
|
||||
* (loopmin to loopmax).
|
||||
* A bracket defines two virtual nodes: the entry and the exit node.
|
||||
* The entry node is the input of the filter and internally connected to the inputs of the children.
|
||||
|
|
@ -181,12 +181,12 @@ class DB_PUBLIC FilterBracket :
|
|||
{
|
||||
public:
|
||||
/**
|
||||
* @brief Constructor (multiplity 1)
|
||||
* @brief Constructor (multiplicity 1)
|
||||
*/
|
||||
FilterBracket (LayoutQuery *q);
|
||||
|
||||
/**
|
||||
* @brief Constructor (multiplity loopmin..loopmax)
|
||||
* @brief Constructor (multiplicity loopmin..loopmax)
|
||||
*/
|
||||
FilterBracket (LayoutQuery *q, unsigned int loopmin, unsigned int loopmax);
|
||||
|
||||
|
|
@ -196,7 +196,7 @@ public:
|
|||
~FilterBracket ();
|
||||
|
||||
/**
|
||||
* @brief Set the min multiplity explicitly
|
||||
* @brief Set the min multiplicity explicitly
|
||||
*/
|
||||
void set_loopmin (unsigned int v)
|
||||
{
|
||||
|
|
@ -204,7 +204,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Set the max multiplity explicitly
|
||||
* @brief Set the max multiplicity explicitly
|
||||
*/
|
||||
void set_loopmax (unsigned int v)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1079,7 +1079,7 @@ LayoutToNetlist::build_nets (const std::vector<const db::Net *> *nets, const db:
|
|||
|
||||
for (db::Circuit::const_net_iterator n = c->begin_nets (); n != c->end_nets (); ++n) {
|
||||
|
||||
// exlude local nets in recursive mode except if they are explicitly selected
|
||||
// exclude local nets in recursive mode except if they are explicitly selected
|
||||
if (! nets && hier_mode != BNH_Disconnected && ! is_top_circuit && n->pin_count () > 0) {
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -862,7 +862,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Variant of the antennna check not using the perimeter
|
||||
* @brief Variant of the antenna check not using the perimeter
|
||||
* This version uses 0 for the perimeter factor hence not taking into account the perimeter at all.
|
||||
*/
|
||||
db::Region antenna_check (const db::Region &gate, const db::Region &metal, double ratio, const std::vector<std::pair<const db::Region *, double> > &diodes = std::vector<std::pair<const db::Region *, double> > ())
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ const db::cell_index_type DropCell = std::numeric_limits<db::cell_index_type>::m
|
|||
* in the cell mapping, a new cell is created. If non-null, final_cell_mapping will hold of list of target layout cells
|
||||
* vs. source layout cells.
|
||||
* Instances are only copied for cells which are created new.
|
||||
* The layer mapping table indentifies target layers for source layout layers.
|
||||
* The layer mapping table identifies target layers for source layout layers.
|
||||
*/
|
||||
void DB_PUBLIC
|
||||
merge_layouts (db::Layout &target, const db::Layout &source, const db::ICplxTrans &trans,
|
||||
|
|
|
|||
|
|
@ -678,7 +678,7 @@ public:
|
|||
/**
|
||||
* @brief Transforms a vector
|
||||
*
|
||||
* Basically the transformation of a vector is ambiguous for pespective transformation because
|
||||
* Basically the transformation of a vector is ambiguous for perspective transformation because
|
||||
* in that case the vector will transform differently depending on the point where the
|
||||
* vector started.
|
||||
*
|
||||
|
|
@ -1032,7 +1032,7 @@ struct MatrixAdjustFlags
|
|||
{
|
||||
enum Flags
|
||||
{
|
||||
None = 0, // Don'd adjust anything
|
||||
None = 0, // Don't adjust anything
|
||||
Displacement = 1, // Adjust displacement only (needs at least one point)
|
||||
Rotation = 2, // Adjust displacement plus rotation (needs two points at least)
|
||||
RotationMirror = 3, // Adjust displacement plus rotation and allow mirror (needs three points at least)
|
||||
|
|
|
|||
|
|
@ -2599,7 +2599,7 @@ NetGraph::derive_node_identities_from_singular_match (const NetGraphNode *n, con
|
|||
return failed_match;
|
||||
}
|
||||
|
||||
// A single candiate: just take this one -> this may render
|
||||
// A single candidate: just take this one -> this may render
|
||||
// inexact matches, but further propagates net pairing
|
||||
|
||||
size_t ni = node_index_for_net (n->net ());
|
||||
|
|
@ -3975,7 +3975,7 @@ NetlistComparer::do_device_assignment (const db::Circuit *c1, const db::NetGraph
|
|||
}
|
||||
good = false;
|
||||
} else {
|
||||
// TODO: report devices which cannot be distiguished topologically?
|
||||
// TODO: report devices which cannot be distinguished topologically?
|
||||
device_map.insert (std::make_pair (k, std::make_pair (d.operator-> (), device_cat)));
|
||||
}
|
||||
|
||||
|
|
@ -4181,7 +4181,7 @@ NetlistComparer::do_subcircuit_assignment (const db::Circuit *c1, const db::NetG
|
|||
}
|
||||
good = false;
|
||||
} else if (valid) {
|
||||
// TODO: report devices which cannot be distiguished topologically?
|
||||
// TODO: report devices which cannot be distinguished topologically?
|
||||
subcircuit_map.insert (std::make_pair (k, std::make_pair (sc.operator-> (), sc_cat)));
|
||||
}
|
||||
|
||||
|
|
@ -4268,7 +4268,7 @@ NetlistComparer::do_subcircuit_assignment (const db::Circuit *c1, const db::NetG
|
|||
|
||||
} else {
|
||||
|
||||
// no unqiue match
|
||||
// no unique match
|
||||
if (mp_logger) {
|
||||
mp_logger->subcircuit_mismatch (0, sc.operator-> ());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -291,7 +291,7 @@ public:
|
|||
* @brief Sets a value indicating depth-first traversal
|
||||
*
|
||||
* With depth first (the default), the algorithm looks for further identities before moving to another
|
||||
* node. With breadth first (false), the algorithm will work in "waves" rather than digging deerly
|
||||
* node. With breadth first (false), the algorithm will work in "waves" rather than digging deeply
|
||||
* into the direction of a node.
|
||||
*/
|
||||
void set_depth_first (bool df)
|
||||
|
|
|
|||
|
|
@ -325,7 +325,7 @@ public:
|
|||
* @brief Sets up the extractor
|
||||
*
|
||||
* This method is supposed to set up the device extractor. This involves two basic steps:
|
||||
* defining the device classe and setting up the device layers.
|
||||
* defining the device classes and setting up the device layers.
|
||||
*
|
||||
* Use "register_device_class" to register the device class you need.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ public:
|
|||
/**
|
||||
* @brief A delegate to handle various forms of devices and translates them
|
||||
*
|
||||
* The reader delegate can be configured to recieve subcircuit elements too.
|
||||
* The reader delegate can be configured to receive subcircuit elements too.
|
||||
* In this case, parameters are allowed.
|
||||
* For receiving subcircuit elements, the delegate needs to indicate
|
||||
* this by returning true upon "wants_subcircuit".
|
||||
|
|
@ -106,7 +106,7 @@ public:
|
|||
* @param element The upper-case element code ("M", "R", ...).
|
||||
* @param name The element's name.
|
||||
* @param model The upper-case model name (may be empty).
|
||||
* @param value The default value (e.g. registance for resistors) and may be zero.
|
||||
* @param value The default value (e.g. resistance for resistors) and may be zero.
|
||||
* @param nets The nets given in the element line.
|
||||
* @param parameters The parameters of the element statement (parameter names are upper case).
|
||||
*
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ public:
|
|||
*
|
||||
* For a detailed description of this method see db::Manager::queue.
|
||||
* This method has been declared to be no-throwing since it is
|
||||
* assumed that once the operation is sucessfully queued it can be undone
|
||||
* assumed that once the operation is successfully queued it can be undone
|
||||
* in every case.
|
||||
*/
|
||||
virtual void undo (db::Op * /*op*/)
|
||||
|
|
@ -100,7 +100,7 @@ public:
|
|||
*
|
||||
* For a detailed description of this method see db::Manager::queue.
|
||||
* This method has been declared to be no-throwing since it is
|
||||
* assumed that once the operation is sucessfully queued it can be redone
|
||||
* assumed that once the operation is successfully queued it can be redone
|
||||
* in every case.
|
||||
*/
|
||||
virtual void redo (db::Op * /*op*/)
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ void path<C>::create_shifted_points (C start, C end, C width, bool forward, Iter
|
|||
|
||||
if (pp == to) {
|
||||
|
||||
// Special case of degenerated path with one point: treat as infinitly small segment with direction (1,0)
|
||||
// Special case of degenerated path with one point: treat as infinitely small segment with direction (1,0)
|
||||
db::DVector ed (forward ? 1.0 : -1.0, 0.0);
|
||||
db::DVector nd (-ed.y (), ed.x ());
|
||||
db::DVector edd, ndd;
|
||||
|
|
@ -350,7 +350,7 @@ void path<C>::create_shifted_points (C start, C end, C width, bool forward, Iter
|
|||
} else {
|
||||
|
||||
// Points in between are determined from taking two
|
||||
// edges being shifted perpendicular from the orginal
|
||||
// edges being shifted perpendicular from the original
|
||||
// and being slightly extended. The intersection point
|
||||
// of both gives the new vertex. If there is no intersection,
|
||||
// the edges are simply connected.
|
||||
|
|
@ -384,7 +384,7 @@ void path<C>::create_shifted_points (C start, C end, C width, bool forward, Iter
|
|||
// Segments are too short - the won't intersect: In this case we create a loop of three
|
||||
// points which define the area in self-overlapping way but confined to the path within
|
||||
// the limits of it's width.
|
||||
// HINT: the execution of this code is a pretty strong evidence for the existance to loops
|
||||
// HINT: the execution of this code is a pretty strong evidence for the existence to loops
|
||||
// in the contour delivered. A proof however is missing ..
|
||||
*pts++ = *pp + vector<C> (nd);
|
||||
*pts++ = *pp;
|
||||
|
|
@ -525,7 +525,7 @@ round_path_corners (const db::DPath &input, double r, int n, double accuracy)
|
|||
// is supposed to create a centerline with roughly the
|
||||
// same length that the ideal line and end segments which are
|
||||
// in the direction of the tangent, so they merge smoothly with
|
||||
// adjancent line segments.
|
||||
// adjacent line segments.
|
||||
double f0 = 1.0 / 3.0;
|
||||
double nn = npts - 1.0 + 2.0 * f0;
|
||||
double ract_outer = ract / cos (f0 * ac / nn);
|
||||
|
|
|
|||
|
|
@ -359,7 +359,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Fuzzy qquality test
|
||||
* @brief Fuzzy equality test
|
||||
*/
|
||||
bool equal (const path<C> &b) const
|
||||
{
|
||||
|
|
@ -1109,7 +1109,7 @@ typedef path_ref<Path, UnitTrans> PathPtr;
|
|||
typedef path_ref<DPath, DUnitTrans> DPathPtr;
|
||||
|
||||
/**
|
||||
* @brief Rounds the path by smooting the corners with a circle approximation
|
||||
* @brief Rounds the path by smoothing the corners with a circle approximation
|
||||
* @param input The input path
|
||||
* @param rad The radius applied to all corners
|
||||
* @param npoints The number of points per full circle used for the circle approximation
|
||||
|
|
@ -1119,7 +1119,7 @@ typedef path_ref<DPath, DUnitTrans> DPathPtr;
|
|||
DB_PUBLIC DPath round_path_corners (const DPath &input, double rad, int npoints, double accuracy);
|
||||
|
||||
/**
|
||||
* @brief Rounds the path by smooting the corners with a circle approximation
|
||||
* @brief Rounds the path by smoothing the corners with a circle approximation
|
||||
* @param input The input path
|
||||
* @param rad The radius applied to all corners
|
||||
* @param npoints The number of points per full circle used for the circle approximation
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ public:
|
|||
/**
|
||||
* @brief Assignment which also converts
|
||||
*
|
||||
* This assignment operator will convert the coordinate types if possibel
|
||||
* This assignment operator will convert the coordinate types if possible
|
||||
*
|
||||
* @param d The source from which to take the data
|
||||
*/
|
||||
|
|
@ -211,7 +211,7 @@ public:
|
|||
/**
|
||||
* @brief Scaling self by some factor
|
||||
*
|
||||
* Scaline involves rounding which in our case is simply handled
|
||||
* Scaling involves rounding which in our case is simply handled
|
||||
* with the coord_traits scheme.
|
||||
*/
|
||||
point<C> &operator*= (double s);
|
||||
|
|
@ -224,7 +224,7 @@ public:
|
|||
/**
|
||||
* @brief Division by some divisor.
|
||||
*
|
||||
* Scaline involves rounding which in our case is simply handled
|
||||
* Scaling involves rounding which in our case is simply handled
|
||||
* with the coord_traits scheme.
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ compute_normals (const db::vector<C> &d, C dx, C dy, int nsign, db::DVector &ed,
|
|||
|
||||
/**
|
||||
* @brief Provides a special DVector vprod sign for the purpose of representing integer-coordinate vectors
|
||||
* The "zero" criterion is somewhat tigher than that of the normal integer value vectors.
|
||||
* The "zero" criterion is somewhat tighter than that of the normal integer value vectors.
|
||||
* Hence, parallelity is somewhat more strict which makes the size function produce a
|
||||
* better approximation to the desired target contour.
|
||||
*/
|
||||
|
|
@ -158,7 +158,7 @@ vprod_sign_for (const db::DVector &a, const db::DVector &b, const db::DVector &)
|
|||
|
||||
/**
|
||||
* @brief Provides a special DVector sprod sign for the purpose of representing integer-coordinate vectors
|
||||
* The "zero" criterion is somewhat tigher than that of the normal integer value vectors.
|
||||
* The "zero" criterion is somewhat tighter than that of the normal integer value vectors.
|
||||
* Hence, orthogonality is somewhat more strict which makes the size function produce a
|
||||
* better approximation to the desired target contour.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -858,7 +858,7 @@ public:
|
|||
* May create invalid (self-overlapping, reverse oriented) contours.
|
||||
* The sign of dx and dy should be identical.
|
||||
*
|
||||
* The mode defines at which bending angle cutoff occures
|
||||
* The mode defines at which bending angle cutoff occurs
|
||||
* 0: >0
|
||||
* 1: >45
|
||||
* 2: >90
|
||||
|
|
@ -2331,7 +2331,7 @@ public:
|
|||
* algorithm using a merge step.
|
||||
* The sign of dx and dy should be identical.
|
||||
*
|
||||
* The mode defines at which bending angle cutoff occures
|
||||
* The mode defines at which bending angle cutoff occurs
|
||||
* 0: >0
|
||||
* 1: >45
|
||||
* 2: >90
|
||||
|
|
|
|||
|
|
@ -474,7 +474,7 @@ void PolygonGenerator::eliminate_hole ()
|
|||
return;
|
||||
}
|
||||
|
||||
// We found the intial edges of a new hole: connect the (partial) hole with a stitch line to the left.
|
||||
// We found the initial edges of a new hole: connect the (partial) hole with a stitch line to the left.
|
||||
// This way we can turn the hole into a non-hole contour.
|
||||
tl_assert (m_open_pos != m_open.begin ());
|
||||
--m_open_pos;
|
||||
|
|
|
|||
|
|
@ -1888,7 +1888,7 @@ rasterize (const db::Polygon &polygon, db::AreaMap &am)
|
|||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Implementation of minkowsky_sum
|
||||
// Implementation of Minkowski sum
|
||||
|
||||
/**
|
||||
* @brief A helper class that produces edges into an EdgeProcessor from a sequence of points
|
||||
|
|
@ -1939,7 +1939,7 @@ private:
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief Produce edges for the partial Minkowsky sum of an edge with an input polygon
|
||||
* @brief Produce edges for the partial Minkowski sum of an edge with an input polygon
|
||||
*/
|
||||
static void
|
||||
ms_production (const db::Polygon &a, const db::Point &p1, const db::Point &p2, db::EdgeProcessor &ep)
|
||||
|
|
|
|||
|
|
@ -130,9 +130,9 @@ template <class PolygonType>
|
|||
void DB_PUBLIC split_polygon (const PolygonType &polygon, std::vector<PolygonType> &output);
|
||||
|
||||
/**
|
||||
* @brief Determines wheter a polygon and a box interact
|
||||
* @brief Determines whether a polygon and a box interact
|
||||
*
|
||||
* This function determines wheter the polygon and the box share at least on common point
|
||||
* This function determines whether the polygon and the box share at least on common point
|
||||
* and returns true in this case.
|
||||
*/
|
||||
template<class Polygon, class Box>
|
||||
|
|
@ -649,22 +649,22 @@ private:
|
|||
bool DB_PUBLIC rasterize (const db::Polygon &polygon, db::AreaMap &am);
|
||||
|
||||
/**
|
||||
* @brief Minkowsky sum of an edge and a polygon
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @brief Minkowsky sum of a polygon and a polygon
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @brief Minkowsky sum of a polygon and a box
|
||||
* @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);
|
||||
|
||||
/**
|
||||
* @brief Minkowsky sum of a polygon and a contour
|
||||
* @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);
|
||||
|
||||
|
|
@ -688,7 +688,7 @@ db::SimplePolygon DB_PUBLIC polygon_to_simple_polygon (const db::Polygon &a);
|
|||
* This mode controls how the polygon is being cut to take off parts.
|
||||
* "PO_any" will deliver a "best" cut. "PO_horizontal" will only apply
|
||||
* horizontal cuts, "PO_vertical" only vertical ones. "PO_htrapezoids" will
|
||||
* apply horizontal cuts to favor horizontal trapzoids. "PO_vtrapezoids"
|
||||
* apply horizontal cuts to favor horizontal trapezoids. "PO_vtrapezoids"
|
||||
* will favor vertical trapezoids.
|
||||
*/
|
||||
enum PreferredOrientation
|
||||
|
|
@ -746,7 +746,7 @@ bool DB_PUBLIC is_convex (const db::SimplePolygon &poly);
|
|||
/**
|
||||
* @brief Decomposes the given polygon into trapezoids
|
||||
*
|
||||
* @param horizontal If true, delivers htrapzeoid objects, otherwise vtrapezoids
|
||||
* @param horizontal If true, delivers htrapezoid objects, otherwise vtrapezoids
|
||||
*
|
||||
* The resulting single polygons will be sent to the sink. Only "put" events will be
|
||||
* generated on the sink.
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ public:
|
|||
/**
|
||||
* @brief Get the id for a name
|
||||
*
|
||||
* This method checks wheter the given name is present as a name and returns the
|
||||
* This method checks whether the given name is present as a name and returns the
|
||||
* id in the second member of the pair. The first member is true, if the name is
|
||||
* present.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ public:
|
|||
* on the layout object beside inserting the objects.
|
||||
* It can be passed options with a layer map which tells which
|
||||
* OASIS layer(s) to read on which logical layers.
|
||||
* In addition, a flag can be passed that tells wheter to create
|
||||
* In addition, a flag can be passed that tells whether to create
|
||||
* new layers. The returned map will contain all layers, the passed
|
||||
* ones and the newly created ones.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ public:
|
|||
/**
|
||||
* @brief Standard constructor for "world" iteration
|
||||
*
|
||||
* This iterator delivers all shapes recursively. The same effect can be acchieved by using a "world" region.
|
||||
* This iterator delivers all shapes recursively. The same effect can be achieved by using a "world" region.
|
||||
*
|
||||
* @param layout The layout from which to get the cell hierarchy
|
||||
* @param cell The starting cell
|
||||
|
|
@ -220,7 +220,7 @@ public:
|
|||
/**
|
||||
* @brief Standard constructor for "world" iteration with a layer set
|
||||
*
|
||||
* This iterator delivers all shapes recursively. The same effect can be acchieved by using a "world" region.
|
||||
* This iterator delivers all shapes recursively. The same effect can be achieved by using a "world" region.
|
||||
*
|
||||
* @param layout The layout from which to get the cell hierarchy
|
||||
* @param cell The starting cell
|
||||
|
|
@ -231,7 +231,7 @@ public:
|
|||
/**
|
||||
* @brief Standard constructor for "world" iteration with a layer set
|
||||
*
|
||||
* This iterator delivers all shapes recursively. The same effect can be acchieved by using a "world" region.
|
||||
* This iterator delivers all shapes recursively. The same effect can be achieved by using a "world" region.
|
||||
*
|
||||
* @param layout The layout from which to get the cell hierarchy
|
||||
* @param cell The starting cell
|
||||
|
|
|
|||
|
|
@ -854,7 +854,7 @@ public:
|
|||
* @brief Scales and grid-snaps the region
|
||||
*
|
||||
* This method will scale the region by mx/dx in horizontal and by my/dy in vertical
|
||||
* direction and then snape to gx and gy respectively.
|
||||
* direction and then snap to gx and gy respectively.
|
||||
*/
|
||||
void scale_and_snap (db::Coord gx, db::Coord mx, db::Coord dx, db::Coord gy, db::Coord my, db::Coord dy);
|
||||
|
||||
|
|
@ -1097,7 +1097,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Selects all polygons of this region which are completly outside polygons from the other region
|
||||
* @brief Selects all polygons of this region which are completely outside polygons from the other region
|
||||
*
|
||||
* Merged semantics applies.
|
||||
*/
|
||||
|
|
@ -1108,7 +1108,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Selects all polygons of this region which are not completly outside polygons from the other region
|
||||
* @brief Selects all polygons of this region which are not completely outside polygons from the other region
|
||||
*
|
||||
* Merged semantics applies.
|
||||
*/
|
||||
|
|
@ -1119,7 +1119,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are completly outside polygons from the other region
|
||||
* @brief Returns all polygons of this which are completely outside polygons from the other region
|
||||
*
|
||||
* This method is an out-of-place version of select_outside.
|
||||
*
|
||||
|
|
@ -1131,7 +1131,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are not completly outside polygons from the other region
|
||||
* @brief Returns all polygons of this which are not completely outside polygons from the other region
|
||||
*
|
||||
* This method is an out-of-place version of select_not_outside.
|
||||
*
|
||||
|
|
@ -1143,7 +1143,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are completly outside polygons from the other region and the opposite ones at the same time
|
||||
* @brief Returns all polygons of this which are completely outside polygons from the other region and the opposite ones at the same time
|
||||
*
|
||||
* This method is equivalent to calling selected_outside and selected_not_outside, but faster.
|
||||
*
|
||||
|
|
@ -1156,7 +1156,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Selects all polygons of this region which are completly inside polygons from the other region
|
||||
* @brief Selects all polygons of this region which are completely inside polygons from the other region
|
||||
*
|
||||
* Merged semantics applies.
|
||||
*/
|
||||
|
|
@ -1167,7 +1167,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Selects all polygons of this region which are not completly inside polygons from the other region
|
||||
* @brief Selects all polygons of this region which are not completely inside polygons from the other region
|
||||
*
|
||||
* Merged semantics applies.
|
||||
*/
|
||||
|
|
@ -1178,7 +1178,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are completly inside polygons from the other region
|
||||
* @brief Returns all polygons of this which are completely inside polygons from the other region
|
||||
*
|
||||
* This method is an out-of-place version of select_inside.
|
||||
*
|
||||
|
|
@ -1190,7 +1190,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are not completly inside polygons from the other region
|
||||
* @brief Returns all polygons of this which are not completely inside polygons from the other region
|
||||
*
|
||||
* This method is an out-of-place version of select_not_inside.
|
||||
*
|
||||
|
|
@ -1202,7 +1202,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are completly inside polygons from the other region and the opposite ones at the same time
|
||||
* @brief Returns all polygons of this which are completely inside polygons from the other region and the opposite ones at the same time
|
||||
*
|
||||
* This method is equivalent to calling selected_inside and selected_not_inside, but faster.
|
||||
*
|
||||
|
|
@ -1261,7 +1261,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Returns all polygons of this which are completly enclosing polygons from the other region and the opposite ones at the same time
|
||||
* @brief Returns all polygons of this which are completely enclosing polygons from the other region and the opposite ones at the same time
|
||||
*
|
||||
* This method is equivalent to calling selected_enclosing and selected_not_enclosing, but faster.
|
||||
*
|
||||
|
|
@ -1617,7 +1617,7 @@ public:
|
|||
Region rounded_corners (double rinner, double router, unsigned int n) const;
|
||||
|
||||
/**
|
||||
* @brief Smoothes the region (in-place)
|
||||
* @brief Smooths the region (in-place)
|
||||
*/
|
||||
void smooth (coord_type d, bool keep_hv);
|
||||
|
||||
|
|
|
|||
|
|
@ -406,7 +406,7 @@ private:
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief Computes the Minkowsky sum between the polygons and the given object
|
||||
* @brief Computes the Minkowski sum between the polygons and the given object
|
||||
* The object can be Edge, Polygon, Box and std::vector<Point>
|
||||
*/
|
||||
template <class K>
|
||||
|
|
|
|||
|
|
@ -239,7 +239,7 @@ SaveLayoutOptions::get_valid_layers (const db::Layout &layout, std::vector <std:
|
|||
|
||||
if (m_all_layers) {
|
||||
|
||||
// collect all layers if neccessary
|
||||
// collect all layers if necessary
|
||||
for (unsigned int l = 0; l < layout.layers (); ++l) {
|
||||
if (layout.is_valid_layer (l)) {
|
||||
const db::LayerProperties &prop = layout.get_properties (l);
|
||||
|
|
|
|||
|
|
@ -915,7 +915,7 @@ public:
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Construct a shape proxy as a reference to a simple olygon
|
||||
* @brief Construct a shape proxy as a reference to a simple polygon
|
||||
*/
|
||||
void init (simple_polygon_type::tag)
|
||||
{
|
||||
|
|
@ -1199,7 +1199,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const polygon_type *basic_ptr (polygon_type::tag) const
|
||||
|
|
@ -1215,7 +1215,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const simple_polygon_type *basic_ptr (simple_polygon_type::tag) const
|
||||
|
|
@ -1231,7 +1231,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const polygon_ref_type *basic_ptr (polygon_ref_type::tag) const
|
||||
|
|
@ -1247,7 +1247,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const polygon_ptr_array_type *basic_ptr (polygon_ptr_array_type::tag) const
|
||||
|
|
@ -1263,7 +1263,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const simple_polygon_ref_type *basic_ptr (simple_polygon_ref_type::tag) const
|
||||
|
|
@ -1279,7 +1279,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const simple_polygon_ptr_array_type *basic_ptr (simple_polygon_ptr_array_type::tag) const
|
||||
|
|
@ -1295,7 +1295,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const path_type *basic_ptr (path_type::tag) const
|
||||
|
|
@ -1311,7 +1311,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const path_ref_type *basic_ptr (path_ref_type::tag) const
|
||||
|
|
@ -1328,7 +1328,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const path_ptr_array_type *basic_ptr (path_ptr_array_type::tag) const
|
||||
|
|
@ -1344,7 +1344,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const edge_type *basic_ptr (edge_type::tag) const
|
||||
|
|
@ -1360,7 +1360,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const edge_pair_type *basic_ptr (edge_pair_type::tag) const
|
||||
|
|
@ -1376,7 +1376,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const text_type *basic_ptr (text_type::tag) const
|
||||
|
|
@ -1392,7 +1392,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const text_ref_type *basic_ptr (text_ref_type::tag) const
|
||||
|
|
@ -1408,7 +1408,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const text_ptr_array_type *basic_ptr (text_ptr_array_type::tag) const
|
||||
|
|
@ -1424,7 +1424,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const user_object_type *basic_ptr (user_object_type::tag) const
|
||||
|
|
@ -1440,7 +1440,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const box_type *basic_ptr (box_type::tag) const
|
||||
|
|
@ -1456,7 +1456,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const box_array_type *basic_ptr (box_array_type::tag) const
|
||||
|
|
@ -1472,7 +1472,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const short_box_type *basic_ptr (short_box_type::tag) const
|
||||
|
|
@ -1488,7 +1488,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const short_box_array_type *basic_ptr (short_box_array_type::tag) const
|
||||
|
|
@ -1504,7 +1504,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<polygon_type> *basic_ptr (db::object_with_properties<polygon_type>::tag) const
|
||||
|
|
@ -1521,7 +1521,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<simple_polygon_type> *basic_ptr (db::object_with_properties<simple_polygon_type>::tag) const
|
||||
|
|
@ -1538,7 +1538,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<polygon_ref_type> *basic_ptr (db::object_with_properties<polygon_ref_type>::tag) const
|
||||
|
|
@ -1555,7 +1555,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<polygon_ptr_array_type> *basic_ptr (db::object_with_properties<polygon_ptr_array_type>::tag) const
|
||||
|
|
@ -1572,7 +1572,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<simple_polygon_ref_type> *basic_ptr (db::object_with_properties<simple_polygon_ref_type>::tag) const
|
||||
|
|
@ -1600,7 +1600,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<path_type> *basic_ptr (db::object_with_properties<path_type>::tag) const
|
||||
|
|
@ -1617,7 +1617,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<path_ref_type> *basic_ptr (db::object_with_properties<path_ref_type>::tag) const
|
||||
|
|
@ -1634,7 +1634,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<path_ptr_array_type> *basic_ptr (db::object_with_properties<path_ptr_array_type>::tag) const
|
||||
|
|
@ -1651,7 +1651,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<edge_type> *basic_ptr (db::object_with_properties<edge_type>::tag) const
|
||||
|
|
@ -1668,7 +1668,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<edge_pair_type> *basic_ptr (db::object_with_properties<edge_pair_type>::tag) const
|
||||
|
|
@ -1685,7 +1685,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<text_type> *basic_ptr (db::object_with_properties<text_type>::tag) const
|
||||
|
|
@ -1702,7 +1702,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<text_ref_type> *basic_ptr (db::object_with_properties<text_ref_type>::tag) const
|
||||
|
|
@ -1719,7 +1719,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<text_ptr_array_type> *basic_ptr (db::object_with_properties<text_ptr_array_type>::tag) const
|
||||
|
|
@ -1736,7 +1736,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<user_object_type> *basic_ptr (db::object_with_properties<user_object_type>::tag) const
|
||||
|
|
@ -1753,7 +1753,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<box_type> *basic_ptr (db::object_with_properties<box_type>::tag) const
|
||||
|
|
@ -1770,7 +1770,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<box_array_type> *basic_ptr (db::object_with_properties<box_array_type>::tag) const
|
||||
|
|
@ -1787,7 +1787,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<short_box_type> *basic_ptr (db::object_with_properties<short_box_type>::tag) const
|
||||
|
|
@ -1804,7 +1804,7 @@ public:
|
|||
/**
|
||||
* @brief Return the actual object that this shape reference is pointing to for objects with properties
|
||||
*
|
||||
* This is a generalisation of the polygon (), etc. methods using a tag to identify the
|
||||
* This is a generalization of the polygon (), etc. methods using a tag to identify the
|
||||
* target object.
|
||||
*/
|
||||
const db::object_with_properties<short_box_array_type> *basic_ptr (db::object_with_properties<short_box_array_type>::tag) const
|
||||
|
|
@ -2630,7 +2630,7 @@ public:
|
|||
*
|
||||
* Ordering of shapes is not specified by the identity of the objects but by the
|
||||
* order of the pointers.
|
||||
* Since pointers are volatile objects, the ordering is not strictly reproducable!
|
||||
* Since pointers are volatile objects, the ordering is not strictly reproducible!
|
||||
*/
|
||||
bool operator< (const Shape &d) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ layer_op<Sh, StableTag>::erase (Shapes *shapes)
|
|||
std::vector<typename db::layer<Sh, StableTag>::iterator> to_erase;
|
||||
to_erase.reserve (m_shapes.size ());
|
||||
|
||||
// This is not quite effective but seems to be the simpliest way
|
||||
// This is not quite effective but seems to be the simplest way
|
||||
// of implementing this: search for each element and erase these.
|
||||
for (typename db::layer<Sh, StableTag>::iterator lsh = shapes->begin (typename Sh::tag (), StableTag ()); lsh != shapes->end (typename Sh::tag (), StableTag ()); ++lsh) {
|
||||
typename std::vector<Sh>::const_iterator s = std::lower_bound (s_begin, s_end, *lsh);
|
||||
|
|
|
|||
|
|
@ -463,7 +463,7 @@ private:
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief A helper class for shape generalisation
|
||||
* @brief A helper class for shape generalization
|
||||
*
|
||||
* This class serves first as a RTTI token for the
|
||||
* various shape-specific layer implementations and
|
||||
|
|
@ -1569,7 +1569,7 @@ private:
|
|||
template <class Trans>
|
||||
shape_type do_insert (const shape_type &shape, const Trans &trans, tl::func_delegate_base <db::properties_id_type> &pm);
|
||||
|
||||
// The insert delegate, specialisation for unit_trans
|
||||
// The insert delegate, specialization for unit_trans
|
||||
shape_type do_insert (const shape_type &shape, const unit_trans_type &trans, tl::func_delegate_base <db::properties_id_type> &pm);
|
||||
|
||||
template <class Sh>
|
||||
|
|
|
|||
|
|
@ -612,7 +612,7 @@ public:
|
|||
* @brief Read a layer mapping from a one-entry-per-line file format
|
||||
*
|
||||
* The format is one expression per line (see map_expr):
|
||||
* <exp> [#commment|//comment]
|
||||
* <exp> [#comment|//comment]
|
||||
* The layer indexes are assigned incrementally starting with 0.
|
||||
* Use "prepare" to assign real indexes for an existing layout.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ public:
|
|||
|
||||
/**
|
||||
* @brief Indicate the end of the execution
|
||||
* @param sucess Will be true if all tiles executed successfully
|
||||
* @param success Will be true if all tiles executed successfully
|
||||
*/
|
||||
virtual void finish (bool /*success*/) { }
|
||||
|
||||
|
|
|
|||
|
|
@ -2561,7 +2561,7 @@ typedef complex_trans<db::Coord, db::DCoord> CplxTrans;
|
|||
* @brief Specialization: concatenation of CplxTrans
|
||||
*
|
||||
* The combination of two of these objects is basically not allowed, since the
|
||||
* output and input types in not compatible. For sake of similicity however, we
|
||||
* output and input types in not compatible. For sake of simplicity however, we
|
||||
* allow this now.
|
||||
*/
|
||||
inline CplxTrans operator* (const CplxTrans &a, const CplxTrans &b)
|
||||
|
|
@ -2578,7 +2578,7 @@ typedef complex_trans<db::DCoord, db::Coord> VCplxTrans;
|
|||
* @brief Specialization: concatenation of VCplxTrans
|
||||
*
|
||||
* The combination of two of these objects is basically not allowed, since the
|
||||
* output and input types in not compatible. For sake of similicity however, we
|
||||
* output and input types in not compatible. For sake of simplicity however, we
|
||||
* allow this now.
|
||||
*/
|
||||
inline VCplxTrans operator* (const VCplxTrans &a, const VCplxTrans &b)
|
||||
|
|
|
|||
|
|
@ -351,7 +351,7 @@ struct coord_traits
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief Coord_traits specialisation for 32 bit coordinates
|
||||
* @brief Coord_traits specialization for 32 bit coordinates
|
||||
*/
|
||||
template <>
|
||||
struct coord_traits<int32_t>
|
||||
|
|
@ -360,7 +360,7 @@ struct coord_traits<int32_t>
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief Coord_traits specialisation for 16 bit coordinates
|
||||
* @brief Coord_traits specialization for 16 bit coordinates
|
||||
*/
|
||||
template <>
|
||||
struct coord_traits<int16_t>
|
||||
|
|
@ -370,7 +370,7 @@ struct coord_traits<int16_t>
|
|||
|
||||
#if defined(HAVE_64BIT_COORD)
|
||||
/**
|
||||
* @brief Coord_traits specialisation for 64 bit coordinates
|
||||
* @brief Coord_traits specialization for 64 bit coordinates
|
||||
*/
|
||||
template <>
|
||||
struct coord_traits<int64_t>
|
||||
|
|
@ -380,7 +380,7 @@ struct coord_traits<int64_t>
|
|||
#endif
|
||||
|
||||
/**
|
||||
* @brief Coord_traits specialisation for double coordinates
|
||||
* @brief Coord_traits specialization for double coordinates
|
||||
*
|
||||
* The precision is chosen such that the double coordinate
|
||||
* can represent "micrometers" with a physical resolution limit of 0.01 nm.
|
||||
|
|
@ -557,7 +557,7 @@ struct epsilon_f
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief And the specialisation of epsilon_f for double
|
||||
* @brief And the specialization of epsilon_f for double
|
||||
*/
|
||||
template <>
|
||||
struct epsilon_f<double>
|
||||
|
|
@ -566,7 +566,7 @@ struct epsilon_f<double>
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief And the specialisation of epsilon_f for float
|
||||
* @brief And the specialization of epsilon_f for float
|
||||
*/
|
||||
template <>
|
||||
struct epsilon_f<float>
|
||||
|
|
|
|||
|
|
@ -44,10 +44,10 @@ namespace db
|
|||
* knots.size == control_points.size + degree + 1
|
||||
* @/code
|
||||
*
|
||||
* The accuracy parameters allow tuing the resolution of the curve to target a specific approximation quality.
|
||||
* The accuracy parameters allow tuning the resolution of the curve to target a specific approximation quality.
|
||||
* "relative_accuracy" gives the accuracy relative to the local curvature radius, "absolute" accuracy gives the
|
||||
* absolute accuracy. "accuracy" is the allowed deviation of polygon approximation from the ideal curve.
|
||||
* The computed curve should meet at least one of the accurcay criteria. Setting both limits to a very small
|
||||
* The computed curve should meet at least one of the accuracy criteria. Setting both limits to a very small
|
||||
* value will result in long run times and a large number of points returned.
|
||||
*
|
||||
* This function supports both rational splines (NURBS) and non-rational splines. The latter use weights of
|
||||
|
|
@ -60,7 +60,7 @@ DB_PUBLIC std::list<P>
|
|||
spline_interpolation (const std::vector<std::pair<P, double> > &control_points, int degree, const std::vector<double> &knots, double relative_accuracy, double absolute_accuracy);
|
||||
|
||||
/**
|
||||
* @brief A convencience version of the previous function
|
||||
* @brief A convenience version of the previous function
|
||||
*
|
||||
* This version takes separate vectors for point and weights for the control points.
|
||||
*/
|
||||
|
|
@ -69,7 +69,7 @@ DB_PUBLIC std::list<P>
|
|||
spline_interpolation (const std::vector<P> &control_points, const std::vector<double> &weights, int degree, const std::vector<double> &knots, double relative_accuracy, double absolute_accuracy);
|
||||
|
||||
/**
|
||||
* @brief A convencience version of the previous function
|
||||
* @brief A convenience version of the previous function
|
||||
*
|
||||
* This version provides non-rational splines and does not take a weight vector.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ void create_shifted_points (C /*c*/, bool forward, Iter from, Iter to, WIter wfr
|
|||
eed *= 1.0 / eed.double_length ();
|
||||
|
||||
// Points in between are determined from taking two
|
||||
// edges being shifted perpendicular from the orginal
|
||||
// edges being shifted perpendicular from the original
|
||||
// and being slightly extended. The intersection point
|
||||
// of both gives the new vertex. If there is no intersection,
|
||||
// the edges are simply connected.
|
||||
|
|
@ -259,7 +259,7 @@ void create_shifted_points (C /*c*/, bool forward, Iter from, Iter to, WIter wfr
|
|||
// Segments are too short - the won't intersect: In this case we create a loop of three
|
||||
// points which define the area in self-overlapping way but confined to the path within
|
||||
// the limits of it's width.
|
||||
// HINT: the execution of this code is a pretty strong evidence for the existance to loops
|
||||
// HINT: the execution of this code is a pretty strong evidence for the existence to loops
|
||||
// in the contour delivered. A proof however is missing ..
|
||||
*pts++ = *pp + vector<C> (nd2);
|
||||
*pts++ = *pp;
|
||||
|
|
|
|||
|
|
@ -156,7 +156,7 @@ public:
|
|||
/**
|
||||
* @brief Assignment which also converts
|
||||
*
|
||||
* This assignment operator will convert the coordinate types if possibel
|
||||
* This assignment operator will convert the coordinate types if possible
|
||||
*
|
||||
* @param d The source from which to take the data
|
||||
*/
|
||||
|
|
@ -296,7 +296,7 @@ public:
|
|||
/**
|
||||
* @brief Division by some divisor.
|
||||
*
|
||||
* Scaline involves rounding which in our case is simply handled
|
||||
* Scaling involves rounding which in our case is simply handled
|
||||
* with the coord_traits scheme.
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ public:
|
|||
* @brief Insert the given cell name for the given cell id
|
||||
*
|
||||
* The name is checked for length and compliance with the character map.
|
||||
* If the name does not comply, it is adjusted acoordingly.
|
||||
* If the name does not comply, it is adjusted accordingly.
|
||||
*/
|
||||
void insert (db::cell_index_type id, const std::string &cell_name);
|
||||
|
||||
|
|
|
|||
|
|
@ -1663,7 +1663,7 @@ Class<db::Cell> decl_Cell ("db", "Cell",
|
|||
"@param dest The layer index of the destination layer\n"
|
||||
) +
|
||||
gsi::method_ext ("copy", ©_from_other_cell, gsi::arg ("src_cell"), gsi::arg ("src_layer"), gsi::arg ("dest"),
|
||||
"@brief Copies shapes from another cell to the target layern this cell\n"
|
||||
"@brief Copies shapes from another cell to the target layer in this cell\n"
|
||||
"\n"
|
||||
"This method will copy all shapes on layer 'src_layer' of cell 'src_cell' to the layer 'dest' of this cell.\n"
|
||||
"The destination layer is not overwritten. Instead, the shapes are added to the shapes of the destination layer.\n"
|
||||
|
|
|
|||
|
|
@ -641,16 +641,16 @@ Class<db::CompoundRegionOperationNode> decl_CompoundRegionOperationNode ("db", "
|
|||
"@brief Creates a node providing merged input polygons.\n"
|
||||
) +
|
||||
gsi::constructor ("new_minkowsky_sum", &new_minkowsky_sum_node1, gsi::arg ("input"), gsi::arg ("e"),
|
||||
"@brief Creates a node providing a Minkowsky sum with an edge.\n"
|
||||
"@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"),
|
||||
"@brief Creates a node providing a Minkowsky sum with a polygon.\n"
|
||||
"@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"),
|
||||
"@brief Creates a node providing a Minkowsky sum with a box.\n"
|
||||
"@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"),
|
||||
"@brief Creates a node providing a Minkowsky sum with a point sequence forming a contour.\n"
|
||||
"@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),
|
||||
"@brief Creates a node providing a width check.\n"
|
||||
|
|
|
|||
|
|
@ -406,7 +406,7 @@ Class<db::EdgeProcessor> decl_EdgeProcessor ("db", "EdgeProcessor",
|
|||
"\n"
|
||||
"The 'mode' parameter describes the corner fill strategy. Mode 0 connects all corner segments directly. Mode 1 is the 'octagon' strategy in which "
|
||||
"square corners are interpolated with a partial octagon. Mode 2 is the standard mode in which corners are filled by expanding edges unless these "
|
||||
"edges form a sharp bend with an angle of more than 90 degree. In that case, the corners are cut off. In Mode 3, no cutoff occures up to a bending angle of 135 degree. "
|
||||
"edges form a sharp bend with an angle of more than 90 degree. In that case, the corners are cut off. In Mode 3, no cutoff occurs up to a bending angle of 135 degree. "
|
||||
"Mode 4 and 5 are even more aggressive and allow very sharp bends without cutoff. This strategy may produce long spikes on sharply bending corners. "
|
||||
"\n"
|
||||
"The result is presented as a set of edges forming closed contours. Hulls are oriented clockwise while\n"
|
||||
|
|
@ -426,7 +426,7 @@ Class<db::EdgeProcessor> decl_EdgeProcessor ("db", "EdgeProcessor",
|
|||
"\n"
|
||||
"This method sizes a set of polygons. Before the sizing is applied, the polygons are merged. After that, sizing is applied \n"
|
||||
"on the individual result polygons of the merge step. The result may contain overlapping polygons, but no self-overlapping ones. \n"
|
||||
"Polygon overlap occures if the polygons are close enough, so a positive sizing makes polygons overlap.\n"
|
||||
"Polygon overlap occurs if the polygons are close enough, so a positive sizing makes polygons overlap.\n"
|
||||
"\n"
|
||||
"dx and dy describe the sizing. A positive value indicates oversize (outwards) while a negative one describes undersize (inwards).\n"
|
||||
"The sizing applied can be chosen differently in x and y direction. In this case, the sign must be identical for both\n"
|
||||
|
|
@ -434,7 +434,7 @@ Class<db::EdgeProcessor> decl_EdgeProcessor ("db", "EdgeProcessor",
|
|||
"\n"
|
||||
"The 'mode' parameter describes the corner fill strategy. Mode 0 connects all corner segments directly. Mode 1 is the 'octagon' strategy in which "
|
||||
"square corners are interpolated with a partial octagon. Mode 2 is the standard mode in which corners are filled by expanding edges unless these "
|
||||
"edges form a sharp bend with an angle of more than 90 degree. In that case, the corners are cut off. In Mode 3, no cutoff occures up to a bending angle of 135 degree. "
|
||||
"edges form a sharp bend with an angle of more than 90 degree. In that case, the corners are cut off. In Mode 3, no cutoff occurs up to a bending angle of 135 degree. "
|
||||
"Mode 4 and 5 are even more aggressive and allow very sharp bends without cutoff. This strategy may produce long spikes on sharply bending corners. "
|
||||
"\n"
|
||||
"This method produces polygons and allows fine-tuning of the parameters for that purpose.\n"
|
||||
|
|
|
|||
|
|
@ -801,7 +801,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"without merging, the + operator is more efficient."
|
||||
) +
|
||||
method ("\\|=", &db::Edges::operator|=, gsi::arg ("other"),
|
||||
"@brief Performs the boolean OR between self and the other redge set\n"
|
||||
"@brief Performs the boolean OR between self and the other edge set\n"
|
||||
"\n"
|
||||
"@return The edge collection after modification (self)\n"
|
||||
"\n"
|
||||
|
|
@ -893,7 +893,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The \"pull_...\" methods are similar to \"select_...\" but work the opposite way: they "
|
||||
"select shapes from the argument region rather than self. In a deep (hierarchical) context "
|
||||
"the output region will be hierarchically aligned with self, so the \"pull_...\" methods "
|
||||
"provide a way for rehierarchisation.\n"
|
||||
"provide a way for re-hierarchization.\n"
|
||||
"\n"
|
||||
"@return The region after the polygons have been selected (from other)\n"
|
||||
"\n"
|
||||
|
|
|
|||
|
|
@ -949,7 +949,7 @@ Class<db::Layout> decl_Layout ("db", "Layout",
|
|||
"\n"
|
||||
"This constructor specifies a manager object which is used to "
|
||||
"store undo information for example. It also allows one to specify whether "
|
||||
"the layout is editable. In editable mode, some optimisations are disabled "
|
||||
"the layout is editable. In editable mode, some optimizations are disabled "
|
||||
"and the layout can be manipulated through a variety of methods.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
|
|
@ -958,7 +958,7 @@ Class<db::Layout> decl_Layout ("db", "Layout",
|
|||
"@brief Creates a layout object\n"
|
||||
"\n"
|
||||
"This constructor specifies whether "
|
||||
"the layout is editable. In editable mode, some optimisations are disabled "
|
||||
"the layout is editable. In editable mode, some optimizations are disabled "
|
||||
"and the layout can be manipulated through a variety of methods.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
|
|
@ -1008,7 +1008,7 @@ Class<db::Layout> decl_Layout ("db", "Layout",
|
|||
"@brief Returns a value indicating whether the layout is editable.\n"
|
||||
"@return True, if the layout is editable.\n"
|
||||
"If a layout is editable, in general manipulation methods are enabled and "
|
||||
"some optimisations are disabled (i.e. shape arrays are expanded).\n"
|
||||
"some optimizations are disabled (i.e. shape arrays are expanded).\n"
|
||||
"\n"
|
||||
"This method has been introduced in version 0.22.\n"
|
||||
) +
|
||||
|
|
@ -1397,7 +1397,7 @@ Class<db::Layout> decl_Layout ("db", "Layout",
|
|||
"@brief Finds or creates a layer with the given name\n"
|
||||
"\n"
|
||||
"If a layer with the given name already exists, this method will return the index of that layer."
|
||||
"If no such layer exists, a new one with theis name will be created and its index will be returned.\n"
|
||||
"If no such layer exists, a new one with this name will be created and its index will be returned.\n"
|
||||
"\n"
|
||||
"This method has been introduced in version 0.23.\n"
|
||||
) +
|
||||
|
|
|
|||
|
|
@ -310,7 +310,7 @@ gsi::Class<db::Matrix2d> decl_Matrix2d ("db", "Matrix2d",
|
|||
"In that case, the assumed execution order of the basic transformations is "
|
||||
"mirroring at the x axis, rotation, magnification and shear.\n"
|
||||
"\n"
|
||||
"The matrix is a generalisation of the transformations and is of limited use in a layout database context. "
|
||||
"The matrix is a generalization of the transformations and is of limited use in a layout database context. "
|
||||
"It is useful however to implement shear transformations on polygons, edges and polygon or edge collections."
|
||||
"\n\n"
|
||||
"This class was introduced in version 0.22.\n"
|
||||
|
|
|
|||
|
|
@ -239,7 +239,7 @@ Class<GenericDeviceExtractor> decl_GenericDeviceExtractor (decl_dbNetlistDeviceE
|
|||
gsi::callback ("setup", &GenericDeviceExtractor::setup, &GenericDeviceExtractor::cb_setup,
|
||||
"@brief Sets up the extractor.\n"
|
||||
"This method is supposed to set up the device extractor. This involves three basic steps:\n"
|
||||
"defining the name, the device classe and setting up the device layers.\n"
|
||||
"defining the name, the device class and setting up the device layers.\n"
|
||||
"\n"
|
||||
"Use \\name= to give the extractor and it's device class a name.\n"
|
||||
"Use \\register_device_class to register the device class you need.\n"
|
||||
|
|
@ -374,7 +374,7 @@ Class<GenericDeviceExtractor> decl_GenericDeviceExtractor (decl_dbNetlistDeviceE
|
|||
" The name is set using \\name=. @/li\n"
|
||||
" @li The device class of the devices to produce. The device class is registered using \\register_device_class. @/li\n"
|
||||
" @li The layers used for the device extraction. These are input layers for the extraction as well as "
|
||||
" output layers for defining the terminals. Terminals are the poins at which the nets connect to the devices.\n"
|
||||
" output layers for defining the terminals. Terminals are the points at which the nets connect to the devices.\n"
|
||||
" Layers are defined using \\define_layer. Initially, layers are abstract definitions with a name and a description.\n"
|
||||
" Concrete layers will be given when defining the connectivity. @/li\n"
|
||||
"@/ul\n"
|
||||
|
|
|
|||
|
|
@ -639,42 +639,42 @@ Class<db::SimplePolygon> decl_SimplePolygon ("db", "SimplePolygon",
|
|||
"This method has been introduced in version 0.25."
|
||||
) +
|
||||
method_ext ("minkowsky_sum", &sp_minkowsky_sum_pe, gsi::arg ("e"), gsi::arg ("resolve_holes"),
|
||||
"@brief Computes the Minkowsky sum of a polygon and an edge\n"
|
||||
"@brief Computes the Minkowski sum of a polygon and an edge\n"
|
||||
"\n"
|
||||
"@param e The edge.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and e.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and e.\n"
|
||||
"\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"),
|
||||
"@brief Computes the Minkowsky sum of a polygon and a polygon\n"
|
||||
"@brief Computes the Minkowski sum of a polygon and a polygon\n"
|
||||
"\n"
|
||||
"@param p The other polygon.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and p.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and p.\n"
|
||||
"\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"),
|
||||
"@brief Computes the Minkowsky sum of a polygon and a box\n"
|
||||
"@brief Computes the Minkowski sum of a polygon and a box\n"
|
||||
"\n"
|
||||
"@param b The box.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and b.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and b.\n"
|
||||
"\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"),
|
||||
"@brief Computes the Minkowsky sum of a polygon and a contour of points (a trace)\n"
|
||||
"@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"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and c.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and c.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
|
|
@ -1788,7 +1788,7 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
|
|||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
method_ext ("smooth", &smooth, gsi::arg ("d"), gsi::arg ("keep_hv", false),
|
||||
"@brief Smoothes a polygon\n"
|
||||
"@brief Smooths a polygon\n"
|
||||
"\n"
|
||||
"Remove vertices that deviate by more than the distance d from the average contour.\n"
|
||||
"The value d is basically the roughness which is removed.\n"
|
||||
|
|
@ -1801,46 +1801,46 @@ Class<db::Polygon> decl_Polygon ("db", "Polygon",
|
|||
"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"),
|
||||
"@brief Computes the Minkowsky sum of the polygon and an edge\n"
|
||||
"@brief Computes the Minkowski sum of the polygon and an edge\n"
|
||||
"\n"
|
||||
"@param e The edge.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum with the edge e.\n"
|
||||
"@return The new polygon representing the Minkowski sum with the edge e.\n"
|
||||
"\n"
|
||||
"The Minkowsky sum of a polygon and an edge basically results in the area covered when "
|
||||
"The Minkowski sum of a polygon and an edge basically results in the area covered when "
|
||||
"\"dragging\" the polygon along the line given by the edge. The effect is similar to drawing the line "
|
||||
"with a pencil that has the shape of the given polygon.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
method_ext ("minkowsky_sum", &minkowsky_sum_pp, gsi::arg ("b"), gsi::arg ("resolve_holes"),
|
||||
"@brief Computes the Minkowsky sum of the polygon and a polygon\n"
|
||||
"@brief Computes the Minkowski sum of the polygon and a polygon\n"
|
||||
"\n"
|
||||
"@param p The first argument.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and p.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and p.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
method_ext ("minkowsky_sum", &minkowsky_sum_pb, gsi::arg ("b"), gsi::arg ("resolve_holes"),
|
||||
"@brief Computes the Minkowsky sum of the polygon and a box\n"
|
||||
"@brief Computes the Minkowski sum of the polygon and a box\n"
|
||||
"\n"
|
||||
"@param b The box.\n"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and the box.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and the box.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
method_ext ("minkowsky_sum", &minkowsky_sum_pc, gsi::arg ("b"), gsi::arg ("resolve_holes"),
|
||||
"@brief Computes the Minkowsky sum of the polygon and a contour of points (a trace)\n"
|
||||
"@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"
|
||||
"@param resolve_holes If true, the output polygon will not contain holes, but holes are resolved by joining the holes with the hull.\n"
|
||||
"\n"
|
||||
"@return The new polygon representing the Minkowsky sum of self and the contour.\n"
|
||||
"@return The new polygon representing the Minkowski sum of self and the contour.\n"
|
||||
"\n"
|
||||
"This method was introduced in version 0.22.\n"
|
||||
) +
|
||||
|
|
|
|||
|
|
@ -369,7 +369,7 @@ namespace gsi
|
|||
"lm.mmap(\"1/17\", 1)\n"
|
||||
"@/code\n"
|
||||
"\n"
|
||||
"'unmapping' allows removing a mapping. This allows creating 'holes' in mapping ranges. The followin example maps "
|
||||
"'unmapping' allows removing a mapping. This allows creating 'holes' in mapping ranges. The following example maps "
|
||||
"layer 1, datatypes 0 to 16 and 18 to 255 to logical layer 0:"
|
||||
"\n"
|
||||
"@code"
|
||||
|
|
|
|||
|
|
@ -389,7 +389,7 @@ Class<db::RecursiveInstanceIterator> decl_RecursiveInstanceIterator ("db", "Recu
|
|||
"@brief Gets the accumulated transformation of the current instance parent cell to the top cell\n"
|
||||
"\n"
|
||||
"This transformation represents how the current instance is seen in the top cell.\n"
|
||||
"This version returns the micon-unit transformation.\n"
|
||||
"This version returns the micron-unit transformation.\n"
|
||||
) +
|
||||
gsi::method ("at_end?", &db::RecursiveInstanceIterator::at_end,
|
||||
"@brief End of iterator predicate\n"
|
||||
|
|
|
|||
|
|
@ -2055,7 +2055,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"The \"pull_...\" methods are similar to \"select_...\" but work the opposite way: they "
|
||||
"select shapes from the argument region rather than self. In a deep (hierarchical) context "
|
||||
"the output region will be hierarchically aligned with self, so the \"pull_...\" methods "
|
||||
"provide a way for rehierarchisation.\n"
|
||||
"provide a way for re-hierarchization.\n"
|
||||
"\n"
|
||||
"@return The region after the polygons have been selected (from other)\n"
|
||||
"\n"
|
||||
|
|
@ -2238,13 +2238,13 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"This method has been introduced in version 0.26."
|
||||
) +
|
||||
method_ext ("minkowsky_sum", &minkowsky_sum_pe, gsi::arg ("e"),
|
||||
"@brief Compute the Minkowsky sum of the region and an edge\n"
|
||||
"@brief Compute the Minkowski sum of the region and an edge\n"
|
||||
"\n"
|
||||
"@param e The edge.\n"
|
||||
"\n"
|
||||
"@return The new polygons representing the Minkowsky sum with the edge e.\n"
|
||||
"@return The new polygons representing the Minkowski sum with the edge e.\n"
|
||||
"\n"
|
||||
"The Minkowsky sum of a region and an edge basically results in the area covered when "
|
||||
"The Minkowski sum of a region and an edge basically results in the area covered when "
|
||||
"\"dragging\" the region along the line given by the edge. The effect is similar to drawing the line "
|
||||
"with a pencil that has the shape of the given region.\n"
|
||||
"\n"
|
||||
|
|
@ -2252,39 +2252,39 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"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"),
|
||||
"@brief Compute the Minkowsky sum of the region and a polygon\n"
|
||||
"@brief Compute the Minkowski sum of the region and a polygon\n"
|
||||
"\n"
|
||||
"@param p The first argument.\n"
|
||||
"\n"
|
||||
"@return The new polygons representing the Minkowsky sum of self and p.\n"
|
||||
"@return The new polygons representing the Minkowski sum of self and p.\n"
|
||||
"\n"
|
||||
"The Minkowsky sum of a region and a polygon is basically the result of \"painting\" "
|
||||
"The Minkowski sum of a region and a polygon is basically the result of \"painting\" "
|
||||
"the region with a pen that has the shape of the second polygon.\n"
|
||||
"\n"
|
||||
"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"),
|
||||
"@brief Compute the Minkowsky sum of the region and a box\n"
|
||||
"@brief Compute the Minkowski sum of the region and a box\n"
|
||||
"\n"
|
||||
"@param b The box.\n"
|
||||
"\n"
|
||||
"@return The new polygons representing the Minkowsky sum of self and the box.\n"
|
||||
"@return The new polygons representing the Minkowski sum of self and the box.\n"
|
||||
"\n"
|
||||
"The result is equivalent to the region-with-polygon Minkowsky sum with the box used "
|
||||
"The result is equivalent to the region-with-polygon Minkowski sum with the box used "
|
||||
"as the second polygon.\n"
|
||||
"\n"
|
||||
"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"),
|
||||
"@brief Compute the Minkowsky sum of the region and a contour of points (a trace)\n"
|
||||
"@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"
|
||||
"\n"
|
||||
"@return The new polygons representing the Minkowsky sum of self and the contour.\n"
|
||||
"@return The new polygons representing the Minkowski sum of self and the contour.\n"
|
||||
"\n"
|
||||
"The Minkowsky sum of a region and a contour basically results in the area covered when "
|
||||
"The Minkowski sum of a region and a contour basically results in the area covered when "
|
||||
"\"dragging\" the region along the contour. The effect is similar to drawing the contour "
|
||||
"with a pencil that has the shape of the given region.\n"
|
||||
"\n"
|
||||
|
|
@ -2968,7 +2968,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@brief A region (a potentially complex area consisting of multiple polygons)\n"
|
||||
"\n\n"
|
||||
"This class was introduced to simplify operations on polygon sets like boolean or sizing operations. "
|
||||
"Regions consist of many polygons and thus are a generalisation of single polygons which describes "
|
||||
"Regions consist of many polygons and thus are a generalization of single polygons which describes "
|
||||
"a single coherence set of points. Regions support a variety of operations and have several states. "
|
||||
"\n\n"
|
||||
"The region's state can be empty (does not contain anything) or box-like, i.e. the region consists "
|
||||
|
|
|
|||
|
|
@ -432,7 +432,7 @@ Class<db::Texts> decl_Texts (decl_dbShapeCollection, "db", "Texts",
|
|||
"The \"pull_...\" method is similar to \"select_...\" but works the opposite way: it "
|
||||
"selects shapes from the argument region rather than self. In a deep (hierarchical) context "
|
||||
"the output region will be hierarchically aligned with self, so the \"pull_...\" method "
|
||||
"provide a way for rehierarchisation.\n"
|
||||
"provide a way for re-hierarchization.\n"
|
||||
"\n"
|
||||
"@return The region after the polygons have been selected (from other)\n"
|
||||
"\n"
|
||||
|
|
|
|||
Loading…
Reference in New Issue