mirror of https://github.com/KLayout/klayout.git
DRC 'collinear mode' becomes 'zero distance mode'
With this change, the default implementation for kissing corners is changed from collinear edges only to touching edges in general. The original mode can be restored by using: l1.space(600.nm, DRCZeroDistanceMode::new(RBA::ZeroDistanceMode::IncludeZeroDistanceWhenCollinearAndTouching)).output(103, 0)
This commit is contained in:
Matthias Koefferlein
parent
87def5d1cc
commit
08b6e6aa9e
|
|
@ -51,13 +51,13 @@ db::Edge::distance_type edge_projection (const db::Edge &a, const db::Edge &b)
|
|||
/**
|
||||
* @brief Gets a flag indicating whether zero distance is included in the checks
|
||||
*/
|
||||
static bool include_zero_flag (collinear_mode_type coll_mode, const db::Edge &a, const db::Edge &b)
|
||||
static bool include_zero_flag (zero_distance_mode zd_mode, const db::Edge &a, const db::Edge &b)
|
||||
{
|
||||
if (coll_mode == AlwaysIncludeCollinear) {
|
||||
if (zd_mode == AlwaysIncludeZeroDistance) {
|
||||
|
||||
return true;
|
||||
|
||||
} else if (coll_mode == NeverIncludeCollinear) {
|
||||
} else if (zd_mode == NeverIncludeZeroDistance) {
|
||||
|
||||
return false;
|
||||
|
||||
|
|
@ -67,14 +67,13 @@ static bool include_zero_flag (collinear_mode_type coll_mode, const db::Edge &a,
|
|||
int s2 = a.side_of (b.p2 ());
|
||||
|
||||
if (s1 == 0 && s2 == 0) {
|
||||
if (coll_mode == IncludeCollinearWhenTouch) {
|
||||
if (zd_mode == IncludeZeroDistanceWhenTouching || zd_mode == IncludeZeroDistanceWhenCollinearAndTouching) {
|
||||
return a.intersect (b);
|
||||
} else if (coll_mode == IncludeCollinearWhenOverlap) {
|
||||
} else if (zd_mode == IncludeZeroDistanceWhenOverlapping) {
|
||||
return a.coincident (b);
|
||||
}
|
||||
// @@@
|
||||
} else if ((s1 == 0 || s2 == 0) && a.p1 () != b.p2 () && a.p2 () != b.p1 ()) {
|
||||
if (coll_mode == IncludeCollinearWhenTouch) {
|
||||
if (zd_mode == IncludeZeroDistanceWhenTouching) {
|
||||
return a.intersect (b);
|
||||
}
|
||||
}
|
||||
|
|
@ -92,7 +91,7 @@ static bool include_zero_flag (collinear_mode_type coll_mode, const db::Edge &a,
|
|||
*
|
||||
* The input edges are normalized to "width" orientation.
|
||||
*/
|
||||
bool euclidian_near_part_of_edge (collinear_mode_type coll_mode, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
|
||||
bool euclidian_near_part_of_edge (zero_distance_mode zd_mode, 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
|
||||
|
|
@ -104,7 +103,7 @@ bool euclidian_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trait
|
|||
int s1 = e.side_of (g.p1 ());
|
||||
int s2 = e.side_of (g.p2 ());
|
||||
|
||||
bool include_zero = include_zero_flag (coll_mode, e, g);
|
||||
bool include_zero = include_zero_flag (zd_mode, e, g);
|
||||
int thr = include_zero ? 0 : -1;
|
||||
|
||||
// keep only part of other which is on the "inside" side of e
|
||||
|
|
@ -122,8 +121,7 @@ bool euclidian_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trait
|
|||
|
||||
db::Point o = g.p1 ();
|
||||
|
||||
int eso = e.side_of (o);
|
||||
if (eso > thr) {
|
||||
if (e.side_of (o) > thr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -228,10 +226,12 @@ bool euclidian_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trait
|
|||
/**
|
||||
* @brief Returns the part of the "other" edge which is on the inside side of e and within distance d
|
||||
*
|
||||
* This function applies Square metrics.
|
||||
* This function applies Projection or Square metrics.
|
||||
* If no such part is found, this function returns false.
|
||||
*
|
||||
* The input edges are normalized to "width" orientation.
|
||||
*/
|
||||
static bool var_near_part_of_edge (collinear_mode_type coll_mode, 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)
|
||||
static bool var_near_part_of_edge (zero_distance_mode zd_mode, 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
|
||||
|
|
@ -244,7 +244,7 @@ static bool var_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trai
|
|||
int s1 = e.side_of (g.p1 ());
|
||||
int s2 = e.side_of (g.p2 ());
|
||||
|
||||
bool include_zero = include_zero_flag (coll_mode, e, g);
|
||||
bool include_zero = include_zero_flag (zd_mode, e, g);
|
||||
int thr = include_zero ? 0 : -1;
|
||||
|
||||
// keep only part of other which is on the "inside" side of e
|
||||
|
|
@ -259,8 +259,10 @@ static bool var_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trai
|
|||
// Handle the case of point vs. edge
|
||||
|
||||
if (g.is_degenerate ()) {
|
||||
double gd = double (e.distance (g.p1 ()));
|
||||
if (gd <= -double (d) || gd >= 0) {
|
||||
if (e.side_of (g.p1 ()) > thr) {
|
||||
return false;
|
||||
}
|
||||
if (double (e.distance (g.p1 ())) <= -double (d)) {
|
||||
return false;
|
||||
}
|
||||
if (db::sprod (db::Vector (g.p1 () - e.p1 ()), e.d ()) < -(dd * e.double_length ())) {
|
||||
|
|
@ -344,9 +346,9 @@ static bool var_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trai
|
|||
* This function applies Projected metrics.
|
||||
* If no such part is found, this function returns false.
|
||||
*/
|
||||
bool projected_near_part_of_edge (collinear_mode_type coll_mode, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
|
||||
bool projected_near_part_of_edge (zero_distance_mode zd_mode, 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 (coll_mode, d, 0, e, other, output);
|
||||
return var_near_part_of_edge (zd_mode, d, 0, e, other, output);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -355,22 +357,22 @@ bool projected_near_part_of_edge (collinear_mode_type coll_mode, db::coord_trait
|
|||
* This function applies Square metrics.
|
||||
* If no such part is found, this function returns false.
|
||||
*/
|
||||
bool square_near_part_of_edge (collinear_mode_type coll_mode, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &other, db::Edge *output)
|
||||
bool square_near_part_of_edge (zero_distance_mode zd_mode, 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 (coll_mode, d, d, e, other, output);
|
||||
return var_near_part_of_edge (zd_mode, d, d, e, other, output);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// Implementation of EdgeRelationFilter
|
||||
|
||||
EdgeRelationFilter::EdgeRelationFilter (edge_relation_type r, distance_type d, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection, collinear_mode_type collinear_mode)
|
||||
: m_whole_edges (false), m_collinear_mode (collinear_mode), m_r (r), m_d (d), m_metrics (metrics), m_ignore_angle (0), m_min_projection (min_projection), m_max_projection (max_projection)
|
||||
EdgeRelationFilter::EdgeRelationFilter (edge_relation_type r, distance_type d, metrics_type metrics, double ignore_angle, distance_type min_projection, distance_type max_projection, zero_distance_mode zd_mode)
|
||||
: m_whole_edges (false), m_zero_distance_mode (zd_mode), m_r (r), m_d (d), m_metrics (metrics), m_ignore_angle (0), m_min_projection (min_projection), m_max_projection (max_projection)
|
||||
{
|
||||
set_ignore_angle (ignore_angle);
|
||||
}
|
||||
|
||||
EdgeRelationFilter::EdgeRelationFilter (edge_relation_type r, distance_type d, const EdgesCheckOptions &options)
|
||||
: m_whole_edges (options.whole_edges), m_collinear_mode (options.collinear_mode), m_r (r), m_d (d), m_metrics (options.metrics), m_ignore_angle (0), m_min_projection (options.min_projection), m_max_projection (options.max_projection)
|
||||
: m_whole_edges (options.whole_edges), m_zero_distance_mode (options.zd_mode), m_r (r), m_d (d), m_metrics (options.metrics), m_ignore_angle (0), m_min_projection (options.min_projection), m_max_projection (options.max_projection)
|
||||
{
|
||||
set_ignore_angle (options.ignore_angle);
|
||||
}
|
||||
|
|
@ -435,14 +437,14 @@ EdgeRelationFilter::check (const db::Edge &a, const db::Edge &b, db::EdgePair *o
|
|||
bool in1, in2;
|
||||
|
||||
if (m_metrics == Euclidian) {
|
||||
in2 = euclidian_near_part_of_edge (m_collinear_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = euclidian_near_part_of_edge (m_collinear_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
in2 = euclidian_near_part_of_edge (m_zero_distance_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = euclidian_near_part_of_edge (m_zero_distance_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
} else if (m_metrics == Square) {
|
||||
in2 = square_near_part_of_edge (m_collinear_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = square_near_part_of_edge (m_collinear_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
in2 = square_near_part_of_edge (m_zero_distance_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = square_near_part_of_edge (m_zero_distance_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
} else {
|
||||
in2 = projected_near_part_of_edge (m_collinear_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = projected_near_part_of_edge (m_collinear_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
in2 = projected_near_part_of_edge (m_zero_distance_mode, m_d, an, bn, ! m_whole_edges && output ? &output->second () : 0);
|
||||
in1 = projected_near_part_of_edge (m_zero_distance_mode, m_d, bn, an, ! m_whole_edges && output ? &output->first () : 0);
|
||||
}
|
||||
|
||||
if (in1 && in2) {
|
||||
|
|
|
|||
|
|
@ -99,28 +99,34 @@ enum edge_relation_type
|
|||
};
|
||||
|
||||
/**
|
||||
* @brief An enum specifying whether how collinear edges are handled
|
||||
* @brief An enum specifying whether how edges with zero distance are handled in checks
|
||||
*/
|
||||
enum collinear_mode_type {
|
||||
/**
|
||||
* @brief Never include collinear edges
|
||||
*/
|
||||
NeverIncludeCollinear = 0,
|
||||
enum zero_distance_mode {
|
||||
|
||||
/**
|
||||
* @brief include collinear edges when they share at least one common point
|
||||
* @brief Never include zero-distance edges
|
||||
*/
|
||||
IncludeCollinearWhenTouch = 1,
|
||||
NeverIncludeZeroDistance = 0,
|
||||
|
||||
/**
|
||||
* @brief include collinear edges when they share more than a single common point
|
||||
* @brief Include zero-distance edges when they share at least one common point
|
||||
*/
|
||||
IncludeCollinearWhenOverlap = 2,
|
||||
IncludeZeroDistanceWhenTouching = 1,
|
||||
|
||||
/**
|
||||
* @brief always include collinear edges
|
||||
* @brief Include zero-distance edges when they share at least one common point and are collinear
|
||||
*/
|
||||
AlwaysIncludeCollinear = 3
|
||||
IncludeZeroDistanceWhenCollinearAndTouching = 2,
|
||||
|
||||
/**
|
||||
* @brief Include zero-distance edges when they share more than a single common point (this implies that they are collinear)
|
||||
*/
|
||||
IncludeZeroDistanceWhenOverlapping = 3,
|
||||
|
||||
/**
|
||||
* @brief Always include zero-distance edges (hardly useful)
|
||||
*/
|
||||
AlwaysIncludeZeroDistance = 4
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -138,13 +144,13 @@ struct DB_PUBLIC EdgesCheckOptions
|
|||
double _ignore_angle = 90,
|
||||
distance_type _min_projection = 0,
|
||||
distance_type _max_projection = std::numeric_limits<distance_type>::max (),
|
||||
collinear_mode_type _collinear_mode = IncludeCollinearWhenTouch)
|
||||
zero_distance_mode _zd_mode = IncludeZeroDistanceWhenTouching)
|
||||
: whole_edges (_whole_edges),
|
||||
metrics (_metrics),
|
||||
ignore_angle (_ignore_angle),
|
||||
min_projection (_min_projection),
|
||||
max_projection (_max_projection),
|
||||
collinear_mode (_collinear_mode)
|
||||
zd_mode (_zd_mode)
|
||||
{ }
|
||||
|
||||
/**
|
||||
|
|
@ -188,13 +194,13 @@ struct DB_PUBLIC EdgesCheckOptions
|
|||
distance_type max_projection;
|
||||
|
||||
/**
|
||||
* @brief Specifies collinear edge handling
|
||||
* @brief Specifies zero-distance edge handling
|
||||
*
|
||||
* This allows implementing the "kissing corners" case. When set to "IncludeCollinearWhenTouch", kissing corners will
|
||||
* be reported as errors, when set to "NeverIncludeCollinear", they won't. Note that with merged inputs, edges
|
||||
* This allows implementing the "kissing corners" case. When set to "IncludeZeroDistanceWhenTouching", kissing corners will
|
||||
* be reported as errors, when set to "NeverIncludeZeroDistance", they won't. Note that with merged inputs, edges
|
||||
* will not overlap except at the corners.
|
||||
*/
|
||||
collinear_mode_type collinear_mode;
|
||||
zero_distance_mode zd_mode;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -222,7 +228,7 @@ struct DB_PUBLIC EdgeRelationFilter
|
|||
* to each other. If the length of the projection of either edge on the other is >= min_projection
|
||||
* or < max_projection, the edges are considered for the check.
|
||||
*/
|
||||
EdgeRelationFilter (edge_relation_type r, distance_type d, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max (), collinear_mode_type include_zero = AlwaysIncludeCollinear);
|
||||
EdgeRelationFilter (edge_relation_type r, distance_type d, metrics_type metrics = db::Euclidian, double ignore_angle = 90, distance_type min_projection = 0, distance_type max_projection = std::numeric_limits<distance_type>::max (), zero_distance_mode include_zero = AlwaysIncludeZeroDistance);
|
||||
|
||||
/**
|
||||
* Constructs an edge relation filter from a CheckOptions structure
|
||||
|
|
@ -254,19 +260,19 @@ struct DB_PUBLIC EdgeRelationFilter
|
|||
}
|
||||
|
||||
/**
|
||||
* @brief Sets a value indicating whether collinear edges shall be included in the check
|
||||
* @brief Sets a value indicating whether zero-distance edges shall be included in the check
|
||||
*/
|
||||
void set_collinear_mode (collinear_mode_type f)
|
||||
void set_zero_distance_mode (zero_distance_mode f)
|
||||
{
|
||||
m_collinear_mode = f;
|
||||
m_zero_distance_mode = f;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Gets a value indicating whether collinear edges shall be included in the check
|
||||
* @brief Gets a value indicating whether zero-distance edges shall be included in the check
|
||||
*/
|
||||
collinear_mode_type collinear_mode () const
|
||||
zero_distance_mode get_zero_distance_mode () const
|
||||
{
|
||||
return m_collinear_mode;
|
||||
return m_zero_distance_mode;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -366,7 +372,7 @@ struct DB_PUBLIC EdgeRelationFilter
|
|||
|
||||
private:
|
||||
bool m_whole_edges;
|
||||
collinear_mode_type m_collinear_mode;
|
||||
zero_distance_mode m_zero_distance_mode;
|
||||
edge_relation_type m_r;
|
||||
distance_type m_d;
|
||||
metrics_type m_metrics;
|
||||
|
|
@ -377,9 +383,9 @@ private:
|
|||
|
||||
// Internal methods exposed for testing purposes
|
||||
|
||||
DB_PUBLIC bool projected_near_part_of_edge (collinear_mode_type include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC bool square_near_part_of_edge (collinear_mode_type include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC bool euclidian_near_part_of_edge (collinear_mode_type include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC bool projected_near_part_of_edge (zero_distance_mode include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC bool square_near_part_of_edge (zero_distance_mode include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC bool euclidian_near_part_of_edge (zero_distance_mode include_zero, db::coord_traits<db::Coord>::distance_type d, const db::Edge &e, const db::Edge &g, db::Edge *output);
|
||||
DB_PUBLIC db::Edge::distance_type edge_projection (const db::Edge &a, const db::Edge &b);
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -130,8 +130,8 @@ struct DB_PUBLIC RegionCheckOptions
|
|||
RectFilter _rect_filter = NoRectFilter,
|
||||
bool _negative = false,
|
||||
PropertyConstraint _prop_constraint = IgnoreProperties,
|
||||
collinear_mode_type _coll_mode = IncludeCollinearWhenTouch)
|
||||
: EdgesCheckOptions (_whole_edges, _metrics, _ignore_angle, _min_projection, _max_projection, _coll_mode),
|
||||
zero_distance_mode _zd_mode = IncludeZeroDistanceWhenTouching)
|
||||
: EdgesCheckOptions (_whole_edges, _metrics, _ignore_angle, _min_projection, _max_projection, _zd_mode),
|
||||
shielded (_shielded),
|
||||
opposite_filter (_opposite_filter),
|
||||
rect_filter (_rect_filter),
|
||||
|
|
|
|||
|
|
@ -390,7 +390,7 @@ static db::CompoundRegionOperationNode *new_edge_pair_to_second_edges (db::Compo
|
|||
return new db::CompoundRegionEdgePairToEdgeProcessingOperationNode (new db::EdgePairToSecondEdgesProcessor (), input, true /*processor is owned*/);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperationNode *other, 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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperationNode *other, 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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
check_non_null (other, "other");
|
||||
|
||||
|
|
@ -405,12 +405,12 @@ static db::CompoundRegionOperationNode *new_check_node (db::CompoundRegionOperat
|
|||
options.opposite_filter = opposite_filter;
|
||||
options.rect_filter = rect_filter;
|
||||
options.negative = negative;
|
||||
options.collinear_mode = collinear_mode;
|
||||
options.zd_mode = zd_mode;
|
||||
|
||||
return new db::CompoundRegionCheckOperationNode (0, other, rel, different_polygons, d, options);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_width_check (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::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_width_check (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::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
db::RegionCheckOptions options (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -419,29 +419,29 @@ static db::CompoundRegionOperationNode *new_width_check (db::Coord d, bool whole
|
|||
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
|
||||
shielded);
|
||||
options.negative = negative;
|
||||
options.collinear_mode = collinear_mode;
|
||||
options.zd_mode = zd_mode;
|
||||
return new db::CompoundRegionToEdgePairProcessingOperationNode (new db::SinglePolygonCheck (db::WidthRelation, d, options), new_primary (), true /*processor is owned*/);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_space_or_isolated_check (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, db::collinear_mode_type collinear_mode, bool negative, bool isolated)
|
||||
static db::CompoundRegionOperationNode *new_space_or_isolated_check (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, db::zero_distance_mode zd_mode, bool negative, bool isolated)
|
||||
{
|
||||
// NOTE: we have to use the "foreign" scheme with a filter because only this scheme
|
||||
// guarantees that all subject shapes are visited and receive all intruders. Having all intruders is crucial for the
|
||||
// semantics of the "drc" feature
|
||||
return new_check_node (new_foreign (), db::SpaceRelation, isolated, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative);
|
||||
return new_check_node (new_foreign (), db::SpaceRelation, isolated, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_space_check (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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_space_check (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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_space_or_isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative, false);
|
||||
return new_space_or_isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative, false);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_isolated_check (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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_isolated_check (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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_space_or_isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative, true);
|
||||
return new_space_or_isolated_check (d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative, true);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_notch_check (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::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_notch_check (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::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
db::RegionCheckOptions options (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -450,28 +450,28 @@ static db::CompoundRegionOperationNode *new_notch_check (db::Coord d, bool whole
|
|||
max_projection.is_nil () ? std::numeric_limits<db::Region::distance_type>::max () : max_projection.to<db::Region::distance_type> (),
|
||||
shielded);
|
||||
options.negative = negative;
|
||||
options.collinear_mode = collinear_mode;
|
||||
options.zd_mode = zd_mode;
|
||||
return new db::CompoundRegionToEdgePairProcessingOperationNode (new db::SinglePolygonCheck (db::SpaceRelation, d, options), new_primary (), true /*processor is owned*/);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_separation_check (db::CompoundRegionOperationNode *other, 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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_separation_check (db::CompoundRegionOperationNode *other, 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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_check_node (other, db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative);
|
||||
return new_check_node (other, db::SpaceRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_overlap_check (db::CompoundRegionOperationNode *other, 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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_overlap_check (db::CompoundRegionOperationNode *other, 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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_check_node (other, db::WidthRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative);
|
||||
return new_check_node (other, db::WidthRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_enclosing_check (db::CompoundRegionOperationNode *other, 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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_enclosing_check (db::CompoundRegionOperationNode *other, 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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_check_node (other, db::OverlapRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative);
|
||||
return new_check_node (other, db::OverlapRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_enclosed_check (db::CompoundRegionOperationNode *other, 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, db::collinear_mode_type collinear_mode, bool negative)
|
||||
static db::CompoundRegionOperationNode *new_enclosed_check (db::CompoundRegionOperationNode *other, 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, db::zero_distance_mode zd_mode, bool negative)
|
||||
{
|
||||
return new_check_node (other, db::InsideRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, collinear_mode, negative);
|
||||
return new_check_node (other, db::InsideRelation, true, d, whole_edges, metrics, ignore_angle, min_projection, max_projection, shielded, opposite_filter, rect_filter, zd_mode, negative);
|
||||
}
|
||||
|
||||
static db::CompoundRegionOperationNode *new_perimeter_filter (db::CompoundRegionOperationNode *input, bool inverse, db::coord_traits<db::Coord>::perimeter_type pmin, db::coord_traits<db::Coord>::perimeter_type pmax)
|
||||
|
|
@ -666,45 +666,45 @@ Class<db::CompoundRegionOperationNode> decl_CompoundRegionOperationNode ("db", "
|
|||
gsi::constructor ("new_minkowski_sum|#new_minkowsky_sum", &new_minkowski_sum_node4, gsi::arg ("input"), gsi::arg ("p"),
|
||||
"@brief Creates a node providing a Minkowski sum with a point sequence forming a contour.\n"
|
||||
) +
|
||||
gsi::constructor ("new_width_check", &new_width_check, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::Euclidian, "Euclidian"), gsi::arg ("ignore_angle", tl::Variant (), "default"), gsi::arg ("min_projection", tl::Variant (), "0"), gsi::arg ("max_projection", tl::Variant (), "max."), gsi::arg ("shielded", true), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing a width check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_space_check", &new_space_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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_space_check", &new_space_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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing a space check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_isolated_check", &new_isolated_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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_isolated_check", &new_isolated_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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing a isolated polygons (space between different polygons) check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_notch_check", &new_notch_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 ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_notch_check", &new_notch_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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing a intra-polygon space check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_separation_check", &new_separation_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_separation_check", &new_separation_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing a separation check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_overlap_check", &new_overlap_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_overlap_check", &new_overlap_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing an overlap check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_enclosing_check", &new_enclosing_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_enclosing_check", &new_enclosing_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing an inside (enclosure) check.\n"
|
||||
"\n"
|
||||
"The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_enclosed_check", &new_enclosed_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch), gsi::arg ("negative", false),
|
||||
gsi::constructor ("new_enclosed_check", &new_enclosed_check, gsi::arg ("other"), 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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching), gsi::arg ("negative", false),
|
||||
"@brief Creates a node providing an enclosed (secondary enclosing primary) check.\n"
|
||||
"\n"
|
||||
"This method has been added in version 0.27.5. The collinear_mode argument has been inserted in version 0.29.\n"
|
||||
"This method has been added in version 0.27.5. The zero_distance_mode argument has been inserted in version 0.29.\n"
|
||||
) +
|
||||
gsi::constructor ("new_perimeter_filter", &new_perimeter_filter, gsi::arg ("input"), gsi::arg ("inverse", false), gsi::arg ("pmin", 0), gsi::arg ("pmax", std::numeric_limits<db::coord_traits<db::Coord>::perimeter_type>::max (), "max"),
|
||||
"@brief Creates a node filtering the input by perimeter.\n"
|
||||
|
|
|
|||
|
|
@ -234,69 +234,69 @@ static db::Edges with_angle3 (const db::Edges *r, db::SpecialEdgeOrientationFilt
|
|||
return r->filtered (f);
|
||||
}
|
||||
|
||||
static db::EdgePairs width2 (const db::Edges *r, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs width2 (const db::Edges *r, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->width_check (d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs space2 (const db::Edges *r, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs space2 (const db::Edges *r, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->space_check (d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs inside2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs inside2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->inside_check (other, d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs overlap2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs overlap2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->overlap_check (other, d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs enclosing2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs enclosing2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->enclosing_check (other, d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs separation2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs separation2 (const db::Edges *r, const db::Edges &other, db::Edges::coord_type d, bool whole_edges, db::metrics_type metrics, const tl::Variant &ignore_angle, const tl::Variant &min_projection, const tl::Variant &max_projection, db::zero_distance_mode zd_mode)
|
||||
{
|
||||
return r->separation_check (other, d, db::EdgesCheckOptions (whole_edges,
|
||||
metrics,
|
||||
ignore_angle.is_nil () ? 90 : ignore_angle.to_double (),
|
||||
min_projection.is_nil () ? db::Edges::distance_type (0) : min_projection.to<db::Edges::distance_type> (),
|
||||
max_projection.is_nil () ? std::numeric_limits<db::Edges::distance_type>::max () : max_projection.to<db::Edges::distance_type> (),
|
||||
collinear_mode)
|
||||
zd_mode)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -1405,7 +1405,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"\n"
|
||||
"This variant has been introduced in version 0.27."
|
||||
) +
|
||||
method_ext ("width_check", &width2, 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("width_check", &width2, 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs a width check with options\n"
|
||||
"@param d The minimum width for which the edges are checked\n"
|
||||
"@param whole_edges If true, deliver the whole edges\n"
|
||||
|
|
@ -1413,7 +1413,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -1432,9 +1432,9 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
|
||||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("space_check", &space2, 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("space_check", &space2, 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs a space check with options\n"
|
||||
"@param d The minimum distance for which the edges are checked\n"
|
||||
"@param whole_edges If true, deliver the whole edges\n"
|
||||
|
|
@ -1442,7 +1442,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the space check.\n"
|
||||
|
|
@ -1461,9 +1461,9 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
|
||||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("inside_check|enclosed_check", &inside2, gsi::arg ("other"), 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("inside_check|enclosed_check", &inside2, gsi::arg ("other"), 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs an inside check with options\n"
|
||||
"@param d The minimum distance for which the edges are checked\n"
|
||||
"@param other The other edge collection against which to check\n"
|
||||
|
|
@ -1472,7 +1472,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -1492,9 +1492,9 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"The 'enclosed_check' alias was introduced in version 0.27.5.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs an enclosing check with options\n"
|
||||
"@param d The minimum distance for which the edges are checked\n"
|
||||
"@param other The other edge collection against which to check\n"
|
||||
|
|
@ -1503,7 +1503,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -1522,9 +1522,9 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
|
||||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs an overlap check with options\n"
|
||||
"@param d The minimum distance for which the edges are checked\n"
|
||||
"@param other The other edge collection against which to check\n"
|
||||
|
|
@ -1533,7 +1533,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -1552,9 +1552,9 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
|
||||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("separation_check", &separation2, gsi::arg ("other"), 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 ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("separation_check", &separation2, gsi::arg ("other"), 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 ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs an overlap check with options\n"
|
||||
"@param d The minimum distance for which the edges are checked\n"
|
||||
"@param other The other edge collection against which to check\n"
|
||||
|
|
@ -1563,7 +1563,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"@param ignore_angle The threshold 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 threshold of the projected length of one edge onto another\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -1582,7 +1582,7 @@ Class<db::Edges> decl_Edges (decl_dbShapeCollection, "db", "Edges",
|
|||
"The projected length must be larger or equal to \"min_projection\" and less than \"max_projection\". "
|
||||
"If you don't want to specify one threshold, pass nil to the respective value.\n"
|
||||
"\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("extents", &extents0,
|
||||
"@brief Returns a region with the bounding boxes of the edges\n"
|
||||
|
|
|
|||
|
|
@ -526,7 +526,7 @@ static db::Region merged_ext2 (db::Region *r, bool min_coherence, int min_wc)
|
|||
return r->merged (min_coherence, std::max (0, min_wc - 1));
|
||||
}
|
||||
|
||||
static db::EdgePairs width2 (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 negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs width2 (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 negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->width_check (d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -538,11 +538,11 @@ static db::EdgePairs width2 (const db::Region *r, db::Region::distance_type d, b
|
|||
db::NoRectFilter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
static db::EdgePairs notch2 (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 negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
static db::EdgePairs notch2 (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 negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->notch_check (d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -554,11 +554,11 @@ static db::EdgePairs notch2 (const db::Region *r, db::Region::distance_type d, b
|
|||
db::NoRectFilter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->isolated_check (d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -570,11 +570,11 @@ static db::EdgePairs isolated2 (const db::Region *r, db::Region::distance_type d
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->space_check (d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -586,11 +586,11 @@ static db::EdgePairs space2 (const db::Region *r, db::Region::distance_type d, b
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->inside_check (other, d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -602,11 +602,11 @@ static db::EdgePairs inside2 (const db::Region *r, const db::Region &other, db::
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->overlap_check (other, d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -618,11 +618,11 @@ static db::EdgePairs overlap2 (const db::Region *r, const db::Region &other, db:
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->enclosing_check (other, d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -634,11 +634,11 @@ static db::EdgePairs enclosing2 (const db::Region *r, const db::Region &other, d
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::collinear_mode_type collinear_mode)
|
||||
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, bool negative, db::PropertyConstraint prop_constraint, db::zero_distance_mode zero_distance_mode)
|
||||
{
|
||||
return r->separation_check (other, d, db::RegionCheckOptions (whole_edges,
|
||||
metrics,
|
||||
|
|
@ -650,7 +650,7 @@ static db::EdgePairs separation2 (const db::Region *r, const db::Region &other,
|
|||
rect_filter,
|
||||
negative,
|
||||
prop_constraint,
|
||||
collinear_mode)
|
||||
zero_distance_mode)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -2597,7 +2597,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"This variant was introduced in version 0.27.\n"
|
||||
) +
|
||||
method_ext ("width_check", &width2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("width_check", &width2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs a width check with options\n"
|
||||
"@param d The minimum width for which the polygons are checked\n"
|
||||
"@param whole_edges If true, deliver the whole edges\n"
|
||||
|
|
@ -2608,7 +2608,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param shielded Enables shielding\n"
|
||||
"@param negative If true, edges not violation the condition will be output as pseudo-edge pairs\n"
|
||||
"@param property_constraint Only \\IgnoreProperties and \\NoPropertyConstraint are allowed - in the last case, properties are copied from the original shapes to the output. "
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"Other than 'width' allow more options here.\n"
|
||||
"\n"
|
||||
"This version is similar to the simple version with one parameter. In addition, it allows "
|
||||
|
|
@ -2640,9 +2640,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The 'shielded' and 'negative' options have been introduced in version 0.27. "
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("space_check", &space2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("space_check", &space2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2654,7 +2654,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative If true, edges not violation the condition will be output as pseudo-edge pairs\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2685,9 +2685,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The 'shielded', 'negative', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("notch_check", ¬ch2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("notch_check", ¬ch2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@brief Performs a space check between edges of the same polygon 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"
|
||||
|
|
@ -2699,7 +2699,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param negative If true, edges not violation the condition will be output as pseudo-edge pairs\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param property_constraint Only \\IgnoreProperties and \\NoPropertyConstraint are allowed - in the last case, properties are copied from the original shapes to the output"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"This version is similar to the simple version with one parameter. In addition, it allows "
|
||||
"to specify many more options.\n"
|
||||
|
|
@ -2730,9 +2730,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The 'shielded' and 'negative' options have been introduced in version 0.27.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("isolated_check", &isolated2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("isolated_check", &isolated2, gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2744,7 +2744,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative If true, edges not violation the condition will be output as pseudo-edge pairs\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2775,9 +2775,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The 'shielded', 'negative', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("inside_check|enclosed_check", &inside2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("inside_check|enclosed_check", &inside2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2790,7 +2790,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative Negative output from the first input\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2828,9 +2828,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"The interpretation of the 'negative' flag has been restriced to first-layout only output in 0.27.1.\n"
|
||||
"The 'enclosed_check' alias was introduced in version 0.27.5.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("overlap_check", &overlap2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2843,7 +2843,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative Negative output from the first input\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2880,9 +2880,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"The 'shielded', 'negative', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27. "
|
||||
"The interpretation of the 'negative' flag has been restriced to first-layout only output in 0.27.1.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("enclosing_check", &enclosing2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2895,7 +2895,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative Negative output from the first input\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2932,9 +2932,9 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"The 'shielded', 'negative', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27. "
|
||||
"The interpretation of the 'negative' flag has been restriced to first-layout only output in 0.27.1.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("separation_check", &separation2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("collinear_mode", db::IncludeCollinearWhenTouch, "IncludeCollinearWhenTouch"),
|
||||
method_ext ("separation_check", &separation2, gsi::arg ("other"), gsi::arg ("d"), gsi::arg ("whole_edges", false), gsi::arg ("metrics", db::metrics_type::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 ("opposite_filter", db::NoOppositeFilter, "NoOppositeFilter"), gsi::arg ("rect_filter", db::NoRectFilter, "NoRectFilter"), gsi::arg ("negative", false), gsi::arg ("property_constraint", db::IgnoreProperties, "IgnoreProperties"), gsi::arg ("zero_distance_mode", db::IncludeZeroDistanceWhenTouching),
|
||||
"@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"
|
||||
|
|
@ -2947,7 +2947,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"@param rect_filter Specifies an error filter for rectangular input shapes\n"
|
||||
"@param negative Negative output from the first input\n"
|
||||
"@param property_constraint Specifies whether to consider only shapes with a certain property relation\n"
|
||||
"@param collinear_mode Specifies how to handle collinear edges\n"
|
||||
"@param zero_distance_mode Specifies how to handle edges with zero distance\n"
|
||||
"\n"
|
||||
"If \"whole_edges\" is true, the resulting \\EdgePairs collection will receive the whole "
|
||||
"edges which contribute in the width check.\n"
|
||||
|
|
@ -2984,7 +2984,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"The 'shielded', 'negative', 'not_opposite' and 'rect_sides' options have been introduced in version 0.27. "
|
||||
"The interpretation of the 'negative' flag has been restriced to first-layout only output in 0.27.1.\n"
|
||||
"'property_constraint' has been added in version 0.28.4.\n"
|
||||
"'collinear_mode' has been added in version 0.29."
|
||||
"'zero_distance_mode' has been added in version 0.29."
|
||||
) +
|
||||
method_ext ("area", &area1,
|
||||
"@brief The area of the region\n"
|
||||
|
|
@ -3263,40 +3263,45 @@ gsi::Enum<db::metrics_type> decl_Metrics ("db", "Metrics",
|
|||
gsi::ClassExt<db::Region> inject_Metrics_in_Region (decl_Metrics.defs ());
|
||||
gsi::ClassExt<db::Edges> inject_Metrics_in_Edges (decl_Metrics.defs ());
|
||||
|
||||
gsi::Enum<db::collinear_mode_type> decl_CollinearMode ("db", "CollinearMode",
|
||||
gsi::enum_const ("NeverIncludeCollinear", db::NeverIncludeCollinear,
|
||||
"@brief Specifies that check functions should never include collinear edges.\n"
|
||||
"With this specification, the check functions will ignore edges which are collinear."
|
||||
gsi::Enum<db::zero_distance_mode> decl_ZeroDistanceMode ("db", "ZeroDistanceMode",
|
||||
gsi::enum_const ("NeverIncludeZeroDistance", db::NeverIncludeZeroDistance,
|
||||
"@brief Specifies that check functions should never include edges with zero distance.\n"
|
||||
"With this specification, the check functions will ignore edges which are collinear or touch."
|
||||
) +
|
||||
gsi::enum_const ("AlwaysIncludeCollinear", db::AlwaysIncludeCollinear,
|
||||
"@brief Specifies that check functions should always include collinear edges\n"
|
||||
"With this specification, the check functions will also check edges which are collinear (in line). "
|
||||
"This also checks edges that are not connected - i.e. do not touch."
|
||||
gsi::enum_const ("AlwaysIncludeZeroDistance", db::AlwaysIncludeZeroDistance,
|
||||
"@hide\n"
|
||||
"@brief Specifies that check functions should always include edges with zero distance\n"
|
||||
"This mode has little practical value.\n"
|
||||
) +
|
||||
gsi::enum_const ("IncludeCollinearWhenTouch", db::IncludeCollinearWhenTouch,
|
||||
"@brief Specifies that check functions should include collinear edges when they touch\n"
|
||||
"With this specification, the check functions will also check edges which are collinear, but only if they share at least one point. "
|
||||
"This is the mode that includes checking the 'kissing corner' cases."
|
||||
gsi::enum_const ("IncludeZeroDistanceWhenTouching", db::IncludeZeroDistanceWhenTouching,
|
||||
"@brief Specifies that check functions should include edges when they touch\n"
|
||||
"With this specification, the check functions will also check edges if they share at least one common point. "
|
||||
"This is the mode that includes checking the 'kissing corner' cases. This mode is default for version 0.29 and later. "
|
||||
) +
|
||||
gsi::enum_const ("IncludeCollinearWhenOverlap", db::IncludeCollinearWhenOverlap,
|
||||
"@brief Specifies that check functions should include collinear edges when they overlap\n"
|
||||
"With this specification, the check functions will also check edges which are collinear, but only if they share more than a single point. "
|
||||
gsi::enum_const ("IncludeZeroDistanceWhenCollinearAndTouching", db::IncludeZeroDistanceWhenCollinearAndTouching,
|
||||
"@brief Specifies that check functions should include edges when they are collinear and touch\n"
|
||||
"With this specification, the check functions will also check edges if they share at least one common point and are collinear. "
|
||||
"This is the mode that includes checking the 'kissing corner' cases when the kissing edges are collinear. This mode was default up to version 0.28. "
|
||||
) +
|
||||
gsi::enum_const ("IncludeZeroDistanceWhenOverlapping", db::IncludeZeroDistanceWhenOverlapping,
|
||||
"@brief Specifies that check functions should include edges when they overlap\n"
|
||||
"With this specification, the check functions will also check edges which are collinear and share more than a single point. "
|
||||
"This is the mode that excludes the 'kissing corner' cases."
|
||||
),
|
||||
"@brief This class represents the collinear_mode type for \\Region#width and related checks.\n"
|
||||
"This mode determines how collinear edges are treated in the DRC checks. Formally these edges do neither represent "
|
||||
"@brief This class represents the zero_distance_mode type for \\Region#width and related checks.\n"
|
||||
"This mode determines how edges with zero distance are treated in the DRC checks. Formally these edges do neither represent "
|
||||
"a space other other relation as they do not face each other. There are three modes available to treat this boundary case: "
|
||||
"Ignore collinear edges (\\NeverIncludeCollinear), always include them (\\AlwaysIncludeCollinear) or only include them "
|
||||
"if they share at least one common point (\\IncludeCollinearWhenTouch). The latter mode allows activating checks for "
|
||||
"Ignore such edges (\\NeverIncludeZeroDistance) or only include them "
|
||||
"if they share at least one common point (\\IncludeZeroDistanceWhenTouching). The latter mode allows activating checks for "
|
||||
"the 'kissing corner' case and is the default mode in most checks."
|
||||
"\n"
|
||||
"This enum has been introduced in version 0.29."
|
||||
);
|
||||
|
||||
// Inject the Region::CollinearMode declarations into Region and Edges:
|
||||
// Inject the Region::ZeroDistanceMode declarations into Region and Edges:
|
||||
// (Edges injection has to be done here because only here defs() is available)
|
||||
gsi::ClassExt<db::Region> inject_CollinearMode_in_Region (decl_CollinearMode.defs ());
|
||||
gsi::ClassExt<db::Edges> inject_CollinearMode_in_Edges (decl_CollinearMode.defs ());
|
||||
gsi::ClassExt<db::Region> inject_ZeroDistanceMode_in_Region (decl_ZeroDistanceMode.defs ());
|
||||
gsi::ClassExt<db::Edges> inject_ZeroDistanceMode_in_Edges (decl_ZeroDistanceMode.defs ());
|
||||
|
||||
gsi::Enum<db::PropertyConstraint> decl_PropertyConstraint ("db", "PropertyConstraint",
|
||||
gsi::enum_const ("IgnoreProperties", db::IgnoreProperties,
|
||||
|
|
|
|||
|
|
@ -51,139 +51,139 @@ TEST(1)
|
|||
TEST(2)
|
||||
{
|
||||
db::Edge output;
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 10), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 10), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;187,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,-50;187,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-87,-50;187,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-87,-50;0,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-94,-34;164,-77)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,0;50,-100)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(40,0;90,-100)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;145,-89)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;145,-89)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(120,0;120,-98)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;100,-100)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;80,-100)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-80,0;-80,-60)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;-45,-89)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,-50;100,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(50,-50;50,-50)");
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), false);
|
||||
EXPECT_EQ (euclidian_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), false);
|
||||
}
|
||||
|
||||
TEST(3)
|
||||
{
|
||||
db::Edge output;
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;200,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,-50;200,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-100,-50;200,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-100,-50;0,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-100,-33;200,-83)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,0;50,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(40,0;90,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;150,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;150,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(120,0;120,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;100,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;80,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-80,0;-80,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;-60,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(-100,0;-100,-100)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,-50;100,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(50,-50;50,-50)");
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), true);
|
||||
EXPECT_EQ (square_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(190,-50;190,-50)");
|
||||
}
|
||||
|
||||
TEST(4)
|
||||
{
|
||||
db::Edge output;
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (100, 200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-50)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-50)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (300, -50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (300, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-50)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -50), db::Point (0, -50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, -100), db::Point (300, -100)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-300, 0), db::Point (300, -100)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,-50;100,-67)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 0), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(0,0;50,-100)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (40, 0), db::Point (140, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(40,0;90,-100)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 0), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, -200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (0, 200), db::Point (200, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (120, 200), db::Point (120, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 200), db::Point (100, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,0;100,-100)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 200), db::Point (80, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;80,-100)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-80, 200), db::Point (-80, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (80, 0), db::Point (-200, -200)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(80,0;0,-57)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (), db::Edge (db::Point (-100, 200), db::Point (-100, -200)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, 50), db::Point (100, 50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (100, -50), db::Point (100, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(100,-50;100,-50)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (50, -50), db::Point (50, -50)), &output), true);
|
||||
EXPECT_EQ (output.to_string (), "(50,-50;50,-50)");
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeCollinear, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), false);
|
||||
EXPECT_EQ (projected_near_part_of_edge (db::AlwaysIncludeZeroDistance, 100, db::Edge (db::Point (0, 0), db::Point (100, 0)), db::Edge (db::Point (190, -50), db::Point (190, -50)), &output), false);
|
||||
}
|
||||
|
||||
TEST(5)
|
||||
|
|
@ -291,7 +291,7 @@ TEST(7)
|
|||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(1,30;1,20)");
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (-1, 30), db::Point (-1, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 30), db::Point (0, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (1, 30), db::Point (1, 20)), &output);
|
||||
|
|
@ -300,7 +300,7 @@ TEST(7)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (-1, 30), db::Point (-1, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::AlwaysIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::AlwaysIncludeZeroDistance);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 300), db::Point (0, -200)), &output);
|
||||
EXPECT_EQ (res, true);
|
||||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(0,110;0,-100)");
|
||||
|
|
@ -309,7 +309,7 @@ TEST(7)
|
|||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(1,110;1,-100)");
|
||||
|
||||
f.set_metrics (db::Square);
|
||||
f.set_collinear_mode (db::AlwaysIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::AlwaysIncludeZeroDistance);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 30), db::Point (0, 20)), &output);
|
||||
EXPECT_EQ (res, true);
|
||||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(0,30;0,20)");
|
||||
|
|
@ -318,7 +318,7 @@ TEST(7)
|
|||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(1,30;1,20)");
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (-1, 30), db::Point (-1, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 30), db::Point (0, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (1, 30), db::Point (1, 20)), &output);
|
||||
|
|
@ -327,7 +327,7 @@ TEST(7)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (-1, 30), db::Point (-1, 20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::AlwaysIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::AlwaysIncludeZeroDistance);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 300), db::Point (0, -200)), &output);
|
||||
EXPECT_EQ (res, true);
|
||||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(0,110;0,-100)");
|
||||
|
|
@ -336,7 +336,7 @@ TEST(7)
|
|||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(1,110;1,-100)");
|
||||
|
||||
f.set_metrics (db::Projection);
|
||||
f.set_collinear_mode (db::AlwaysIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::AlwaysIncludeZeroDistance);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 30), db::Point (0, -20)), &output);
|
||||
EXPECT_EQ (res, true);
|
||||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(0,10;0,0)");
|
||||
|
|
@ -345,7 +345,7 @@ TEST(7)
|
|||
EXPECT_EQ (output.first ().to_string () + ":" + output.second ().to_string (), "(0,0;0,10):(1,10;1,0)");
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (-1, 30), db::Point (-1, -20)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (0, 30), db::Point (0, 11)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 10)), db::Edge (db::Point (1, 30), db::Point (1, -20)), &output);
|
||||
|
|
@ -361,7 +361,7 @@ TEST(8_KissingCornerProblem)
|
|||
// if the projection is >0.
|
||||
|
||||
db::EdgeRelationFilter f (db::WidthRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
db::EdgePair output;
|
||||
bool res;
|
||||
|
||||
|
|
@ -382,7 +382,7 @@ TEST(8_KissingCornerProblem)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, -1), db::Point (0, -100)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenOverlap);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenOverlapping);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, 201), db::Point (0, 101)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -398,7 +398,7 @@ TEST(8_KissingCornerProblem)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, -1), db::Point (0, -100)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, 201), db::Point (0, 101)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -414,7 +414,7 @@ TEST(8_KissingCornerProblem)
|
|||
EXPECT_EQ (res, false);
|
||||
|
||||
f = db::EdgeRelationFilter (db::SpaceRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
|
||||
f.set_metrics (db::Euclidian);
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
|
|
@ -433,7 +433,7 @@ TEST(8_KissingCornerProblem)
|
|||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, -100), db::Point (0, -1)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenOverlap);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenOverlapping);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -449,7 +449,7 @@ TEST(8_KissingCornerProblem)
|
|||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, -100), db::Point (0, -1)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
f.set_metrics (db::Euclidian);
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
|
|
@ -472,7 +472,7 @@ TEST(9_KissingCornerProblemSquareMetrics)
|
|||
// if the projection is >0.
|
||||
|
||||
db::EdgeRelationFilter f (db::WidthRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
db::EdgePair output;
|
||||
bool res;
|
||||
|
||||
|
|
@ -493,7 +493,7 @@ TEST(9_KissingCornerProblemSquareMetrics)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, -1), db::Point (0, -100)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, 201), db::Point (0, 101)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -509,7 +509,7 @@ TEST(9_KissingCornerProblemSquareMetrics)
|
|||
EXPECT_EQ (res, false);
|
||||
|
||||
f = db::EdgeRelationFilter (db::SpaceRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
|
||||
f.set_metrics (db::Square);
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
|
|
@ -528,7 +528,7 @@ TEST(9_KissingCornerProblemSquareMetrics)
|
|||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, -100), db::Point (0, -1)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -550,7 +550,7 @@ TEST(10_KissingCornerProblemProjectionMetrics)
|
|||
// if the projection is >0. It is not effective in projection metrics as there is no overlap.
|
||||
|
||||
db::EdgeRelationFilter f (db::WidthRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
db::EdgePair output;
|
||||
bool res;
|
||||
|
||||
|
|
@ -569,7 +569,7 @@ TEST(10_KissingCornerProblemProjectionMetrics)
|
|||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, -1), db::Point (0, -100)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 0), db::Point (0, 100)), db::Edge (db::Point (0, 201), db::Point (0, 101)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
@ -585,7 +585,7 @@ TEST(10_KissingCornerProblemProjectionMetrics)
|
|||
EXPECT_EQ (res, false);
|
||||
|
||||
f = db::EdgeRelationFilter (db::SpaceRelation, 10);
|
||||
f.set_collinear_mode (db::IncludeCollinearWhenTouch);
|
||||
f.set_zero_distance_mode (db::IncludeZeroDistanceWhenTouching);
|
||||
|
||||
f.set_metrics (db::Projection);
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
|
|
@ -602,7 +602,7 @@ TEST(10_KissingCornerProblemProjectionMetrics)
|
|||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, -100), db::Point (0, -1)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
||||
f.set_collinear_mode (db::NeverIncludeCollinear);
|
||||
f.set_zero_distance_mode (db::NeverIncludeZeroDistance);
|
||||
|
||||
res = f.check (db::Edge (db::Point (0, 100), db::Point (0, 0)), db::Edge (db::Point (0, 101), db::Point (0, 201)), &output);
|
||||
EXPECT_EQ (res, false);
|
||||
|
|
|
|||
|
|
@ -1485,7 +1485,7 @@ CODE
|
|||
shielded = nil
|
||||
opposite_filter = RBA::Region::NoOppositeFilter
|
||||
rect_filter = RBA::Region::NoRectFilter
|
||||
collinear_mode = RBA::Region::IncludeCollinearWhenTouch
|
||||
zd_mode = RBA::Region::IncludeZeroDistanceWhenTouching
|
||||
|
||||
n = 1
|
||||
args.each do |a|
|
||||
|
|
@ -1495,8 +1495,8 @@ CODE
|
|||
whole_edges = a.value
|
||||
elsif a.is_a?(DRCPropertiesConstraint)
|
||||
prop_constraint = a.value
|
||||
elsif a.is_a?(DRCCollinearMode)
|
||||
collinear_mode = a.value
|
||||
elsif a.is_a?(DRCZeroDistanceMode)
|
||||
zd_mode = a.value
|
||||
elsif a.is_a?(DRCOppositeErrorFilter)
|
||||
opposite_filter = a.value
|
||||
elsif a.is_a?(DRCRectangleErrorFilter)
|
||||
|
|
@ -1529,7 +1529,7 @@ CODE
|
|||
raise("A rectangle error filter cannot be used with this check")
|
||||
end
|
||||
|
||||
args << collinear_mode
|
||||
args << zd_mode
|
||||
|
||||
if :#{f} == :width || :#{f} == :space || :#{f} == :notch || :#{f} == :isolated
|
||||
other && raise("No other layer must be specified for a single-layer check")
|
||||
|
|
|
|||
|
|
@ -324,13 +324,13 @@ module DRC
|
|||
|
||||
def without_touching(f = true)
|
||||
self._context("without_touching") do
|
||||
DRCCollinearMode::new(f ? RBA::Region::IncludeCollinearWhenOverlap : RBA::Region::IncludeCollinearWhenTouch)
|
||||
DRCZeroDistanceMode::new(f ? RBA::Region::IncludeZeroDistanceWhenOverlapping : RBA::Region::IncludeZeroDistanceWhenTouching)
|
||||
end
|
||||
end
|
||||
|
||||
def without_coincident(f = true)
|
||||
self._context("without_coincident") do
|
||||
DRCCollinearMode::new(f ? RBA::Region::NeverIncludeCollinear : RBA::Region::IncludeCollinearWhenTouch)
|
||||
DRCZeroDistanceMode::new(f ? RBA::Region::NeverIncludeZeroDistance : RBA::Region::IncludeZeroDistanceWhenTouching)
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -3937,7 +3937,7 @@ CODE
|
|||
# Like \width and \space, the separation check also supports the "without_touching" option.
|
||||
#
|
||||
# This option will turn off errors that arise due to
|
||||
# collinear edges touching in one corner (the "kissing corners" configuration).
|
||||
# edges touching in one corner (the "kissing corners" configuration).
|
||||
# By default, such edges will yield an error, as they
|
||||
# form a zero-distance situation. With this option in place, no errors will be reported.
|
||||
#
|
||||
|
|
@ -4179,7 +4179,7 @@ CODE
|
|||
opposite_filter = RBA::Region::NoOppositeFilter
|
||||
rect_filter = RBA::Region::NoRectFilter
|
||||
prop_constraint = RBA::Region::IgnoreProperties
|
||||
collinear_mode = RBA::Region::IncludeCollinearWhenTouch
|
||||
zd_mode = RBA::Region::IncludeZeroDistanceWhenTouching
|
||||
|
||||
n = 1
|
||||
args.each do |a|
|
||||
|
|
@ -4191,8 +4191,8 @@ CODE
|
|||
negative = true
|
||||
elsif a.is_a?(DRCPropertiesConstraint)
|
||||
prop_constraint = a.value
|
||||
elsif a.is_a?(DRCCollinearMode)
|
||||
collinear_mode = a.value
|
||||
elsif a.is_a?(DRCZeroDistanceMode)
|
||||
zd_mode = a.value
|
||||
elsif a.is_a?(DRCOppositeErrorFilter)
|
||||
opposite_filter = a.value
|
||||
elsif a.is_a?(DRCRectangleErrorFilter)
|
||||
|
|
@ -4246,7 +4246,7 @@ CODE
|
|||
raise("A rectangle error filter can only be used for polygon layers")
|
||||
end
|
||||
|
||||
args << collinear_mode
|
||||
args << zd_mode
|
||||
|
||||
border = (metrics == RBA::Region::Square ? value * 1.5 : value)
|
||||
|
||||
|
|
|
|||
|
|
@ -95,10 +95,10 @@ module DRC
|
|||
end
|
||||
end
|
||||
|
||||
# A wrapper for the "collinear mode" for
|
||||
# A wrapper for the "zero distance mode" for
|
||||
# the DRC functions. The purpose of this class
|
||||
# is to identify the value by the class.
|
||||
class DRCCollinearMode
|
||||
class DRCZeroDistanceMode
|
||||
attr_accessor :value
|
||||
def initialize(v)
|
||||
self.value = v
|
||||
|
|
|
|||
|
|
@ -1617,12 +1617,22 @@ TEST(89_deep_with_mag_cop_size_aniso)
|
|||
run_test (_this, "89", true);
|
||||
}
|
||||
|
||||
TEST(90_collinear_mode)
|
||||
TEST(90_zero_distance_mode)
|
||||
{
|
||||
run_test (_this, "90", false);
|
||||
}
|
||||
|
||||
TEST(90d_collinear_mode)
|
||||
TEST(90d_zero_distance_mode)
|
||||
{
|
||||
run_test (_this, "90", true);
|
||||
}
|
||||
|
||||
TEST(91_zero_distance_mode)
|
||||
{
|
||||
run_test (_this, "91", false);
|
||||
}
|
||||
|
||||
TEST(91d_zero_distance_mode)
|
||||
{
|
||||
run_test (_this, "91", true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,34 @@
|
|||
|
||||
source $drc_test_source
|
||||
target $drc_test_target
|
||||
|
||||
if $drc_test_deep
|
||||
deep
|
||||
end
|
||||
|
||||
l1 = input(1, 0)
|
||||
|
||||
l1.output(1, 0)
|
||||
|
||||
l1.space(600.nm).output(100, 0)
|
||||
l1.space(600.nm, without_touching).output(101, 0)
|
||||
l1.space(600.nm, without_coincident).output(102, 0)
|
||||
l1.space(600.nm, DRCZeroDistanceMode::new(RBA::ZeroDistanceMode::IncludeZeroDistanceWhenCollinearAndTouching)).output(103, 0)
|
||||
|
||||
l1.space(600.nm, projection).output(110, 0)
|
||||
l1.space(600.nm, projection, without_touching).output(111, 0)
|
||||
l1.space(600.nm, projection, without_coincident).output(112, 0)
|
||||
l1.space(600.nm, projection, DRCZeroDistanceMode::new(RBA::ZeroDistanceMode::IncludeZeroDistanceWhenCollinearAndTouching)).output(113, 0)
|
||||
|
||||
l1.space(600.nm, square).output(120, 0)
|
||||
l1.space(600.nm, square, without_touching).output(121, 0)
|
||||
l1.space(600.nm, square, without_coincident).output(122, 0)
|
||||
l1.space(600.nm, square, DRCZeroDistanceMode::new(RBA::ZeroDistanceMode::IncludeZeroDistanceWhenCollinearAndTouching)).output(123, 0)
|
||||
|
||||
l1.data.min_coherence = true
|
||||
|
||||
l1.space(600.nm).output(200, 0)
|
||||
l1.space(600.nm, without_touching).output(201, 0)
|
||||
l1.space(600.nm, without_coincident).output(202, 0)
|
||||
l1.space(600.nm, DRCZeroDistanceMode::new(RBA::ZeroDistanceMode::IncludeZeroDistanceWhenCollinearAndTouching)).output(203, 0)
|
||||
|
||||
Binary file not shown.
Loading…
Reference in New Issue