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

WIP: bugfix and tests for opposite filter for DRC

This commit is contained in:
Matthias Koefferlein 2020-12-06 10:56:56 +01:00
parent 574660174e
commit 6c4d1f4ef3
10 changed files with 344 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/db/db/dbAsIfFlatRegion.cc
View File

@ -1109,7 +1109,7 @@ AsIfFlatRegion::run_check (db::edge_relation_type rel, bool different_polygons,
check.set_min_projection (options.min_projection);
check.set_max_projection (options.max_projection);
db::check_local_operation<db::Polygon, db::Polygon> op (check, different_polygons, other != 0, other && other->is_merged (), options.shielded, options.not_opposite, options.rect_filter);
db::check_local_operation<db::Polygon, db::Polygon> op (check, different_polygons, other != 0, other && other->is_merged (), options.shielded, options.opposite_filter, options.rect_filter);
db::local_processor<db::Polygon, db::Polygon, db::EdgePair> proc;
proc.set_base_verbosity (base_verbosity ());

4
src/db/db/dbCompoundOperation.cc
View File

@ -1116,14 +1116,14 @@ CompoundRegionCheckOperationNode::CompoundRegionCheckOperationNode (db::edge_rel
void
CompoundRegionCheckOperationNode::do_compute_local (db::Layout *layout, const shape_interactions<db::Polygon, db::Polygon> &interactions, std::vector<std::unordered_set<db::EdgePair> > &results, size_t max_vertex_count, double area_ratio) const
{
db::check_local_operation<db::Polygon, db::Polygon> op (m_check, m_different_polygons, true, false, m_options.shielded, m_options.not_opposite, m_options.rect_filter);
db::check_local_operation<db::Polygon, db::Polygon> op (m_check, m_different_polygons, true, false, m_options.shielded, m_options.opposite_filter, m_options.rect_filter);
op.compute_local (layout, interactions, results, max_vertex_count, area_ratio);
}
void
CompoundRegionCheckOperationNode::do_compute_local (db::Layout *layout, const shape_interactions<db::PolygonRef, db::PolygonRef> &interactions, std::vector<std::unordered_set<db::EdgePair> > &results, size_t max_vertex_count, double area_ratio) const
{
db::check_local_operation<db::PolygonRef, db::PolygonRef> op (m_check, m_different_polygons, true, false, m_options.shielded, m_options.not_opposite, m_options.rect_filter);
db::check_local_operation<db::PolygonRef, db::PolygonRef> op (m_check, m_different_polygons, true, false, m_options.shielded, m_options.opposite_filter, m_options.rect_filter);
op.compute_local (layout, interactions, results, max_vertex_count, area_ratio);
}

2
src/db/db/dbDeepRegion.cc
View File

@ -1488,7 +1488,7 @@ DeepRegion::run_check (db::edge_relation_type rel, bool different_polygons, cons
std::auto_ptr<db::DeepEdgePairs> res (new db::DeepEdgePairs (polygons.derived ()));
db::CheckLocalOperation op (check, different_polygons, other_deep != 0, other && other->is_merged (), options.shielded, options.not_opposite, options.rect_filter);
db::CheckLocalOperation op (check, different_polygons, other_deep != 0, other && other->is_merged (), options.shielded, options.opposite_filter, options.rect_filter);
db::local_processor<db::PolygonRef, db::PolygonRef, db::EdgePair> proc (const_cast<db::Layout *> (&polygons.layout ()),
const_cast<db::Cell *> (&polygons.initial_cell ()),

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

@ -54,7 +54,7 @@ db::Edge::distance_type edge_projection (const db::Edge &a, const db::Edge &b)
* This function applies Euclidian metrics.
* If no such part is found, this function returns false.
*/
bool euclidian_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge &e, const db::Edge &other, db::Edge *output)
bool euclidian_near_part_of_edge (bool include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
{
// Handle the case of point-like basic edge: cannot determine
// orientation
@ -119,7 +119,7 @@ bool euclidian_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge
// handle the parallel case
if (e.parallel (g)) {
if (std::abs (e.distance (g.p1 ())) >= d) {
if (std::abs (double (e.distance (g.p1 ()))) >= double (d)) {
return false;
}
} else {
@ -197,7 +197,7 @@ bool euclidian_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge
* This function applies Square metrics.
* If no such part is found, this function returns false.
*/
static bool var_near_part_of_edge (bool include_zero, db::Coord d, db::Coord dd, const db::Edge &e, const db::Edge &other, db::Edge *output)
static bool var_near_part_of_edge (bool include_zero, db::coord_traits<db::Coord>::distance_type d, db::coord_traits<db::Coord>::distance_type dd, const db::Edge &e, const db::Edge &other, db::Edge *output)
{
// Handle the case of point-like basic edge: cannot determine
// orientation
@ -229,14 +229,14 @@ static bool var_near_part_of_edge (bool include_zero, db::Coord d, db::Coord dd,
// Handle the case of point vs. edge
if (g.is_degenerate ()) {
db::Coord gd = e.distance (g.p1 ());
if (gd <= -d || gd >= 0) {
double gd = double (e.distance (g.p1 ()));
if (gd <= -double (d) || gd >= 0) {
return false;
}
if (db::sprod (db::Vector (g.p1 () - e.p1 ()), e.d ()) < -dd * e.double_length ()) {
if (db::sprod (db::Vector (g.p1 () - e.p1 ()), e.d ()) < -(dd * e.double_length ())) {
return false;
}
if (db::sprod (db::Vector (e.p2 () - g.p1 ()), e.d ()) < -dd * e.double_length ()) {
if (db::sprod (db::Vector (e.p2 () - g.p1 ()), e.d ()) < -(dd * e.double_length ())) {
return false;
}
if (output) {
@ -255,7 +255,7 @@ static bool var_near_part_of_edge (bool include_zero, db::Coord d, db::Coord dd,
// handle the parallel case
if (e.parallel (g)) {
if (std::abs (e.distance (g.p1 ())) >= d) {
if (std::abs (double (e.distance (g.p1 ()))) >= double (d)) {
return false;
}
} else {
@ -275,8 +275,8 @@ static bool var_near_part_of_edge (bool include_zero, db::Coord d, db::Coord dd,
}
if (db::sprod_sign (e, g) == 0) {
if (db::sprod (db::Vector (g.p1 () - e.p1 ()), e.d ()) < -dd * e.double_length () ||
db::sprod (db::Vector (e.p2 () - g.p1 ()), e.d ()) < -dd * e.double_length ()) {
if (db::sprod (db::Vector (g.p1 () - e.p1 ()), e.d ()) < -(dd * e.double_length ()) ||
db::sprod (db::Vector (e.p2 () - g.p1 ()), e.d ()) < -(dd * e.double_length ())) {
return false;
}
} else {
@ -314,7 +314,7 @@ static bool var_near_part_of_edge (bool include_zero, db::Coord d, db::Coord dd,
* This function applies Projected metrics.
* If no such part is found, this function returns false.
*/
bool projected_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge &e, const db::Edge &other, db::Edge *output)
bool projected_near_part_of_edge (bool include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
{
return var_near_part_of_edge (include_zero, d, 0, e, other, output);
}
@ -325,7 +325,7 @@ bool projected_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge
* This function applies Square metrics.
* If no such part is found, this function returns false.
*/
bool square_near_part_of_edge (bool include_zero, db::Coord d, const db::Edge &e, const db::Edge &other, db::Edge *output)
bool square_near_part_of_edge (bool include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
{
return var_near_part_of_edge (include_zero, d, d, e, other, output);
}

10
src/db/db/dbRegionDelegate.h
View File

@ -61,7 +61,7 @@ struct DB_PUBLIC RegionCheckOptions
distance_type _min_projection = 0,
distance_type _max_projection = std::numeric_limits<distance_type>::max (),
bool _shielded = true,
bool _no_opposite = false,
OppositeFilter _opposite_filter = NoOppositeFilter,
RectFilter _rect_filter = NoSideAllowed)
: whole_edges (_whole_edges),
metrics (_metrics),
@ -69,7 +69,7 @@ struct DB_PUBLIC RegionCheckOptions
min_projection (_min_projection),
max_projection (_max_projection),
shielded (_shielded),
not_opposite (_no_opposite),
opposite_filter (_opposite_filter),
rect_filter (_rect_filter)
{ }
@ -121,11 +121,9 @@ struct DB_PUBLIC RegionCheckOptions
bool shielded;
/**
* @brief Suppresses opposite error edges
*
* If true, error edges opposite of each other across the respective polygon part cancel.
* @brief Specifies the opposite filter
*/
bool not_opposite;
OppositeFilter opposite_filter;
/**
* @brief Specifies a filter for error markers on rectangular shapes

29
src/db/db/dbRegionLocalOperations.cc
View File

@ -169,8 +169,8 @@ static bool shields_interaction (const db::EdgePair &ep, const P &poly)
template <class TS, class TI>
check_local_operation<TS, TI>::check_local_operation (const EdgeRelationFilter &check, bool different_polygons, bool has_other, bool other_is_merged, bool shielded, bool no_opposite, db::RectFilter rect_filter)
: m_check (check), m_different_polygons (different_polygons), m_has_other (has_other), m_other_is_merged (other_is_merged), m_shielded (shielded), m_no_opposite (no_opposite), m_rect_filter (rect_filter)
check_local_operation<TS, TI>::check_local_operation (const EdgeRelationFilter &check, bool different_polygons, bool has_other, bool other_is_merged, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
: m_check (check), m_different_polygons (different_polygons), m_has_other (has_other), m_other_is_merged (other_is_merged), m_shielded (shielded), m_opposite_filter (opposite_filter), m_rect_filter (rect_filter)
{
// .. nothing yet ..
}
@ -181,7 +181,7 @@ check_local_operation<TS, TI>::compute_local (db::Layout *layout, const shape_in
{
tl_assert (results.size () == 1);
std::unordered_set<db::EdgePair> &result = results.front ();
tl_assert (results.empty ());
tl_assert (result.empty ());
edge2edge_check<std::unordered_set<db::EdgePair> > edge_check (m_check, result, m_different_polygons, m_has_other, m_shielded);
poly2poly_check<TS, std::unordered_set<db::EdgePair> > poly_check (edge_check);
@ -256,9 +256,9 @@ check_local_operation<TS, TI>::compute_local (db::Layout *layout, const shape_in
scanner.process (poly_check, m_check.distance (), db::box_convert<TS> ());
} while (edge_check.prepare_next_pass ());
// detect and remove parts of the result which have results "opposite"
// ("opposite" is defined by the projection part)
if (m_no_opposite && ! result.empty ()) {
// detect and remove parts of the result which have or do not have results "opposite"
// ("opposite" is defined by the projection of edges "through" the subject shape)
if (m_opposite_filter != db::NoOppositeFilter && ! result.empty ()) {
db::EdgeRelationFilter opp (db::WidthRelation, std::numeric_limits<db::EdgeRelationFilter::distance_type>::max (), db::Projection);
@ -270,9 +270,11 @@ check_local_operation<TS, TI>::compute_local (db::Layout *layout, const shape_in
projections.clear ();
std::unordered_set<db::EdgePair>::const_iterator ep2 = ep1;
++ep2;
for ( ; ep2 != result.end (); ++ep2) {
for (std::unordered_set<db::EdgePair>::const_iterator ep2 = result.begin (); ep2 != result.end (); ++ep2) {
if (ep1 == ep2) {
continue;
}
db::EdgePair ep_opp;
if (opp.check (ep1->first (), ep2->first (), &ep_opp)) {
@ -291,11 +293,16 @@ check_local_operation<TS, TI>::compute_local (db::Layout *layout, const shape_in
}
if (! projections.empty ()) {
db::Edges ce = db::Edges (ep1->first ()) - db::Edges (projections.begin (), projections.end ());
db::Edges ce;
if (m_opposite_filter == db::OnlyOpposite) {
ce = db::Edges (ep1->first ()) & db::Edges (projections.begin (), projections.end ());
} else if (m_opposite_filter == db::NotOpposite) {
ce = db::Edges (ep1->first ()) - db::Edges (projections.begin (), projections.end ());
}
for (db::Edges::const_iterator re = ce.begin (); ! re.at_end (); ++re) {
cleaned_result.insert (db::EdgePair (*re, ep1->second ()));
}
} else {
} else if (m_opposite_filter == db::NotOpposite) {
cleaned_result.insert (*ep1);
}

25
src/db/db/dbRegionLocalOperations.h
View File

@ -68,12 +68,33 @@ enum RectFilter
ThreeSidesAllowed
};
/**
* @brief Specifies an error filter for opposite errors
*/
enum OppositeFilter
{
/**
* @brief No filter
*/
NoOppositeFilter,
/**
* @brief Only errors appearing on opposite sides of a figure will be reported
*/
OnlyOpposite,
/**
* @brief Only errors NOT appearing on opposite sides of a figure will be reported
*/
NotOpposite
};
template <class TS, class TI>
class check_local_operation
: public local_operation<TS, TI, db::EdgePair>
{
public:
check_local_operation (const EdgeRelationFilter &check, bool different_polygons, bool has_other, bool other_is_merged, bool shielded, bool no_opposite, db::RectFilter rect_filter);
check_local_operation (const EdgeRelationFilter &check, bool different_polygons, bool has_other, bool other_is_merged, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter);
virtual void compute_local (db::Layout * /*layout*/, const shape_interactions<TS, TI> &interactions, std::vector<std::unordered_set<db::EdgePair> > &results, size_t /*max_vertex_count*/, double /*area_ratio*/) const;
@ -87,7 +108,7 @@ private:
bool m_has_other;
bool m_other_is_merged;
bool m_shielded;
bool m_no_opposite;
db::OppositeFilter m_opposite_filter;
db::RectFilter m_rect_filter;
};

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

@ -174,7 +174,7 @@ static db::CompoundRegionOperationNode *new_minkowsky_sum_node4 (db::CompoundReg
return new db::CompoundRegionProcessingOperationNode (new db::minkowsky_sum_computation<std::vector<db::Point> > (p), input, true /*processor is owned*/);
}
static db::CompoundRegionOperationNode *new_check_node (db::edge_relation_type rel, bool different_polygons, db::Coord d, bool whole_edges, const tl::Variant &metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_check_node (db::edge_relation_type rel, bool different_polygons, db::Coord d, bool whole_edges, const tl::Variant &metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new db::CompoundRegionCheckOperationNode (rel, different_polygons, d,
db::RegionCheckOptions (whole_edges,
@ -183,12 +183,12 @@ static db::CompoundRegionOperationNode *new_check_node (db::edge_relation_type r
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
no_opposite,
opposite_filter,
rect_filter)
);
}
static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperationNode *input, db::edge_relation_type rel, bool different_polygons, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperationNode *input, db::edge_relation_type rel, bool different_polygons, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new db::CompoundRegionCheckOperationNode (input, rel, different_polygons, d,
db::RegionCheckOptions (whole_edges,
@ -197,39 +197,39 @@ static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperat
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
no_opposite,
opposite_filter,
rect_filter)
);
}
static db::CompoundRegionOperationNode *new_width_check_node (db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded)
{
return new_check_node (db::WidthRelation, false, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, false, db::NoSideAllowed);
return new_check_node (db::WidthRelation, false, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, db::NoOppositeFilter, db::NoSideAllowed);
}
static db::CompoundRegionOperationNode *new_space_check_node (db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_space_check_node (db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new_check_node (db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, no_opposite, rect_filter);
return new_check_node (db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter);
}
static db::CompoundRegionOperationNode *new_notch_check_node (db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded)
{
return new_check_node (db::SpaceRelation, false, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, false, db::NoSideAllowed);
return new_check_node (db::SpaceRelation, false, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, db::NoOppositeFilter, db::NoSideAllowed);
}
static db::CompoundRegionOperationNode *new_separation_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_separation_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new_check_node (input, db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, no_opposite, rect_filter);
return new_check_node (input, db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter);
}
static db::CompoundRegionOperationNode *new_overlap_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_overlap_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new_check_node (input, db::OverlapRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, no_opposite, rect_filter);
return new_check_node (input, db::OverlapRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter);
}
static db::CompoundRegionOperationNode *new_inside_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool no_opposite, db::RectFilter rect_filter)
static db::CompoundRegionOperationNode *new_inside_check_node (db::CompoundRegionOperationNode *input, db::Coord d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite_filter, db::RectFilter rect_filter)
{
return new_check_node (input, db::InsideRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, no_opposite, rect_filter);
return new_check_node (input, db::InsideRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter);
}
static db::CompoundRegionOperationNode *new_perimeter_filter (db::CompoundRegionOperationNode *input, db::coord_traits<db::Coord>::perimeter_type pmin, db::coord_traits<db::Coord>::perimeter_type pmax, bool inverse)
@ -334,19 +334,19 @@ Class<db::CompoundRegionOperationNode> decl_CompoundRegionOperationNode ("db", "
gsi::constructor ("new_width_check", &new_width_check_node, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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),
"@brief Creates a node providing a width check.\n"
) +
gsi::constructor ("new_space_check", &new_space_check_node, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
gsi::constructor ("new_space_check", &new_space_check_node, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Creates a node providing a space check.\n"
) +
gsi::constructor ("new_notch_check", &new_notch_check_node, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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),
"@brief Creates a node providing a intra-polygon space check.\n"
) +
gsi::constructor ("new_separation_check", &new_separation_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
gsi::constructor ("new_separation_check", &new_separation_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Creates a node providing a separation check.\n"
) +
gsi::constructor ("new_overlap_check", &new_overlap_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
gsi::constructor ("new_overlap_check", &new_overlap_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Creates a node providing an overlap check.\n"
) +
gsi::constructor ("new_inside_check", &new_inside_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
gsi::constructor ("new_inside_check", &new_inside_check_node, gsi::arg ("input"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Creates a node providing an inside (enclosure) check.\n"
) +
gsi::constructor ("new_perimeter_filter", &new_perimeter_filter, gsi::arg ("input"), gsi::arg ("pmin", 0), gsi::arg ("pmax", std::numeric_limits<db::coord_traits<db::Coord>::perimeter_type>::max (), "max"), gsi::arg ("inverse", false),
@ -481,7 +481,7 @@ gsi::Enum<db::PreferredOrientation> decl_dbPreferredOrientation ("db", "Preferre
"This enum has been introduced in version 0.27."
);
gsi::EnumIn<db::RegionBBoxFilter, db::RegionBBoxFilter::parameter_type> decl_dbRegionBBoxFilter_ParameterType ("db", "ParameterType",
gsi::EnumIn<db::CompoundRegionOperationNode, db::RegionBBoxFilter::parameter_type> decl_dbRegionBBoxFilter_ParameterType ("db", "ParameterType",
gsi::enum_const ("BoxWidth", db::RegionBBoxFilter::BoxWidth,
"@brief Measures the width of the bounding box\n"
) +

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

@ -449,7 +449,7 @@ static db::EdgePairs width2 (const db::Region *r, db::Region::distance_type d, b
);
}
static db::EdgePairs space2 (const db::Region *r, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs space2 (const db::Region *r, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->space_check (d, db::RegionCheckOptions (whole_edges,
metrics,
@ -457,7 +457,7 @@ static db::EdgePairs space2 (const db::Region *r, db::Region::distance_type d, b
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
@ -473,7 +473,7 @@ static db::EdgePairs notch2 (const db::Region *r, db::Region::distance_type d, b
);
}
static db::EdgePairs isolated2 (const db::Region *r, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs isolated2 (const db::Region *r, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->isolated_check (d, db::RegionCheckOptions (whole_edges,
metrics,
@ -481,12 +481,12 @@ static db::EdgePairs isolated2 (const db::Region *r, db::Region::distance_type d
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
static db::EdgePairs inside2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs inside2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->inside_check (other, d, db::RegionCheckOptions (whole_edges,
metrics,
@ -494,12 +494,12 @@ static db::EdgePairs inside2 (const db::Region *r, const db::Region &other, db::
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
static db::EdgePairs overlap2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs overlap2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->overlap_check (other, d, db::RegionCheckOptions (whole_edges,
metrics,
@ -507,12 +507,12 @@ static db::EdgePairs overlap2 (const db::Region *r, const db::Region &other, db:
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
static db::EdgePairs enclosing2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs enclosing2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->enclosing_check (other, d, db::RegionCheckOptions (whole_edges,
metrics,
@ -520,12 +520,12 @@ static db::EdgePairs enclosing2 (const db::Region *r, const db::Region &other, d
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
static db::EdgePairs separation2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, bool not_opposite, db::RectFilter rect_filter)
static db::EdgePairs separation2 (const db::Region *r, const db::Region &other, db::Region::distance_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, bool shielded, db::OppositeFilter opposite, db::RectFilter rect_filter)
{
return r->separation_check (other, d, db::RegionCheckOptions (whole_edges,
metrics,
@ -533,7 +533,7 @@ static db::EdgePairs separation2 (const db::Region *r, const db::Region &other,
min_projection.is_nil () ? db::Region::distance_type (0) : min_projection.to<db::Region::distance_type> (),
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
shielded,
not_opposite,
opposite,
rect_filter)
);
}
@ -2015,7 +2015,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"\n"
"The 'shielded' option has been introduced in version 0.27."
) +
method_ext ("space_check", &space2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
method_ext ("space_check", &space2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs a space check with options\n"
"@param d The minimum space for which the polygons are checked\n"
"@param whole_edges If true, deliver the whole edges\n"
@ -2023,13 +2023,11 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param shielded Enables shielding\n"
"\n"
"This version is similar to the simple version with one parameter. In addition, it allows "
"to specify many more options.\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the space check.\n"
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
@ -2051,7 +2049,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
@ -2098,7 +2096,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"\n"
"The 'shielded' option has been introduced in version 0.27."
) +
method_ext ("isolated_check", &isolated2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
method_ext ("isolated_check", &isolated2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs a space check between edges of different polygons with options\n"
"@param d The minimum space for which the polygons are checked\n"
"@param whole_edges If true, deliver the whole edges\n"
@ -2106,185 +2104,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param shielded Enables shielding\n"
"\n"
"This version is similar to the simple version with one parameter. In addition, it allows "
"to specify many more options.\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the space check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("inside_check", &inside2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an inside check with options\n"
"@param d The minimum distance for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param shielded Enables shielding\n"
"\n"
"This version is similar to the simple version with one parameter. In addition, it allows "
"to specify many more options.\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an overlap check with options\n"
"@param d The minimum overlap for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param shielded Enables shielding\n"
"\n"
"This version is similar to the simple version with one parameter. In addition, it allows "
"to specify many more options.\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an enclosing check with options\n"
"@param d The minimum enclosing distance for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param shielded Enables shielding\n"
"@param not_opposite Reports error edges only if not opposite to other edges on the original figure\n"
"@param rect_filter Filters out certain allowed errors on rectangle input shapes\n"
"\n"
"This version is similar to the simple version with one parameter. In addition, it allows "
"to specify many more options.\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("separation_check", &separation2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("not_opposite", false), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs a separation check with options\n"
"@param d The minimum separation for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param not_opposite Reports error edges only if not opposite to other edges on the original figure\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
@ -2310,7 +2130,175 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"not_opposite\" will supress all errors happening on both of two opposite sides of the input figures. "
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("inside_check", &inside2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an inside check with options\n"
"@param d The minimum distance for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an overlap check with options\n"
"@param d The minimum overlap for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs an enclosing check with options\n"
"@param d The minimum enclosing distance for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
"\n"
"The 'shielded', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27."
) +
method_ext ("separation_check", &separation2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter), gsi::arg ("rect_filter", db::NoSideAllowed),
"@brief Performs a separation check with options\n"
"@param d The minimum separation for which the polygons are checked\n"
"@param other The other region against which to check\n"
"@param whole_edges If true, deliver the whole edges\n"
"@param metrics Specify the metrics type\n"
"@param ignore_angle The angle above which no check is performed\n"
"@param min_projection The lower threshold of the projected length of one edge onto another\n"
"@param max_projection The upper limit of the projected length of one edge onto another\n"
"@param opposite_filter Specifies a filter mode for errors happening on opposite sides of inputs shapes\n"
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
"\n"
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
"edges which contribute in the width check.\n"
"\n"
"\"metrics\" can be one of the constants \\Euclidian, \\Square or \\Projection. See there for "
"a description of these constants.\n"
"Use nil for this value to select the default (Euclidian metrics).\n"
"\n"
"\"ignore_angle\" specifies the angle limit of two edges. If two edges form an angle equal or "
"above the given value, they will not contribute in the check. "
"Setting this value to 90 (the default) will exclude edges with an angle of 90 degree or more from the check.\n"
"Use nil for this value to select the default.\n"
"\n"
"\"min_projection\" and \"max_projection\" allow selecting edges by their projected value upon each other. "
"It is sufficient if the projection of one edge on the other matches the specified condition. "
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
"If you don't want to specify one limit, pass nil to the respective value.\n"
"\n"
"\"shielded\" controls whether shielding is applied. Shielding means that rule violations are not "
"detected 'through' other features. Measurements are only made where the opposite edge is unobstructed.\n"
"Shielding often is not optional as a rule violation in shielded case automatically comes with rule "
"violations between the original and the shielding features. If not necessary, shielding can be disabled by setting this flag to "
"false. In general, this will improve performance somewhat.\n"
"\n"
"\"opposite_filter\" specifies whether to require or reject errors happening on opposite sides of a figure. "
"\"rect_filter\" allows suppressing specific error configurations on rectangular input figures.\n"
"\n"
"Merged semantics applies for the input of this method (see \\merged_semantics= of merged semantics)\n"
@ -2546,5 +2534,21 @@ gsi::EnumIn<db::Region, db::RectFilter> decl_Region_RectFilter ("db", "RectFilte
"This enum has been introduced in version 0.27."
);
gsi::EnumIn<db::Region, db::OppositeFilter> decl_Region_OppositeFilter ("db", "OppositeFilter",
gsi::enum_const ("NoOppositeFilter", db::OppositeFilter::NoOppositeFilter,
"@brief No opposite filtering\n"
) +
gsi::enum_const ("OnlyOpposite", db::OppositeFilter::OnlyOpposite,
"@brief Only errors appearing on opposite sides of a figure will be reported\n"
) +
gsi::enum_const ("NotOpposite", db::OppositeFilter::NotOpposite,
"@brief Only errors NOT appearing on opposite sides of a figure will be reported\n"
),
"@brief This class represents the opposite error filter mode for \\Region#separation and related checks.\n"
"\n"
"This enum has been introduced in version 0.27."
);
}

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

@ -583,7 +583,7 @@ TEST(15d)
EXPECT_EQ (r.space_check (120, db::RegionCheckOptions (false, db::Projection)).to_string (), "(300,100;400,100)/(400,200;300,200);(300,160;350,160)/(350,200;300,200);(0,160;100,160)/(100,200;0,200);(350,140;300,140)/(300,100;350,100);(0,100;100,100)/(100,140;0,140);(600,100;700,100)/(700,200;600,200)");
}
TEST(15e)
TEST(15e)
{
// #650
db::Region r;
@ -631,7 +631,65 @@ TEST(15e)
EXPECT_EQ (r.space_check (1000).to_string (), "(20857,3600;20857,66000)/(19957,66000;19957,3600)");
}
TEST(16)
TEST(15g)
{
// opposite_filter
db::Region r2;
r2.insert (db::Box (db::Point (0, 0), db::Point (90, 300)));
r2.insert (db::Box (db::Point (210, 100), db::Point (300, 200)));
db::Region r1;
r1.insert (db::Box (db::Point (100, 0), db::Point (200, 300)));
db::RegionCheckOptions options;
options.metrics = db::Projection;
options.opposite_filter = db::NoOppositeFilter;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(200,200;200,100)/(210,100;210,200);(100,0;100,300)/(90,300;90,0)");
options.opposite_filter = db::NotOpposite;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(100,200;100,300)/(90,300;90,0);(100,0;100,100)/(90,300;90,0)");
options.opposite_filter = db::OnlyOpposite;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(100,100;100,200)/(90,300;90,0);(200,200;200,100)/(210,100;210,200)");
}
TEST(15h)
{
// opposite_filter with internal shielding
// shielding within opposite error detection
db::Region r2;
r2.insert (db::Box (db::Point (0, 0), db::Point (90, 100)));
r2.insert (db::Box (db::Point (0, 200), db::Point (90, 300)));
r2.insert (db::Box (db::Point (210, 0), db::Point (300, 100)));
r2.insert (db::Box (db::Point (210, 200), db::Point (300, 300)));
db::Region r1;
r1.insert (db::Box (db::Point (100, 0), db::Point (140, 300)));
r1.insert (db::Box (db::Point (140, 0), db::Point (160, 200)));
r1.insert (db::Box (db::Point (160, 0), db::Point (200, 300)));
db::RegionCheckOptions options;
options.shielded = false; // does NOT disable internal shielding for "opposite"
options.metrics = db::Projection;
options.opposite_filter = db::NoOppositeFilter;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(100,0;100,100)/(90,100;90,0);(200,100;200,0)/(210,0;210,100);(100,200;100,300)/(90,300;90,200);(200,300;200,200)/(210,200;210,300)");
options.opposite_filter = db::NotOpposite;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(200,300;200,200)/(210,200;210,300);(100,200;100,300)/(90,300;90,200)");
options.opposite_filter = db::OnlyOpposite;
EXPECT_EQ (r1.separation_check (r2, 40, options).to_string (),
"(200,100;200,0)/(210,0;210,100);(100,0;100,100)/(90,100;90,0)");
}
TEST(16)
{
db::Region a;
a.insert (db::Box (db::Point (10, 20), db::Point (20, 30)));