mirror of https://github.com/KLayout/klayout.git
split_* operations in DRC (interacting/non_interacting in one step), doc, tests.
This commit is contained in:
Matthias Koefferlein
parent
570c79e446
commit
e639c30570
|
|
@ -267,6 +267,16 @@ public:
|
|||
return mp_delegate;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Takes the underlying delegate object
|
||||
*/
|
||||
RegionDelegate *take_delegate ()
|
||||
{
|
||||
RegionDelegate *delegate = mp_delegate;
|
||||
mp_delegate = 0;
|
||||
return delegate;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Sets the base verbosity
|
||||
*
|
||||
|
|
|
|||
|
|
@ -610,15 +610,53 @@ static db::EdgePairs separation2 (const db::Region *r, const db::Region &other,
|
|||
);
|
||||
}
|
||||
|
||||
static inline std::vector<db::Region> as_2region_vector (const std::pair<db::Region, db::Region> &rp)
|
||||
{
|
||||
std::vector<db::Region> res;
|
||||
res.reserve (2);
|
||||
res.push_back (db::Region (const_cast<db::Region &> (rp.first).take_delegate ()));
|
||||
res.push_back (db::Region (const_cast<db::Region &> (rp.second).take_delegate ()));
|
||||
return res;
|
||||
}
|
||||
|
||||
static std::vector<db::Region> andnot (const db::Region *r, const db::Region &other)
|
||||
{
|
||||
std::pair<db::Region, db::Region> rp = r->andnot (other);
|
||||
return as_2region_vector (r->andnot (other));
|
||||
}
|
||||
|
||||
std::vector<db::Region> res;
|
||||
res.resize (2, db::Region ());
|
||||
res [0] = rp.first;
|
||||
res [1] = rp.second;
|
||||
return res;
|
||||
static std::vector<db::Region> split_inside (const db::Region *r, const db::Region &other)
|
||||
{
|
||||
return as_2region_vector (r->selected_inside_differential (other));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_outside (const db::Region *r, const db::Region &other)
|
||||
{
|
||||
return as_2region_vector (r->selected_outside_differential (other));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_overlapping (const db::Region *r, const db::Region &other, size_t min_count, size_t max_count)
|
||||
{
|
||||
return as_2region_vector (r->selected_overlapping_differential (other, min_count, max_count));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_covering (const db::Region *r, const db::Region &other, size_t min_count, size_t max_count)
|
||||
{
|
||||
return as_2region_vector (r->selected_enclosing_differential (other, min_count, max_count));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_interacting_with_region (const db::Region *r, const db::Region &other, size_t min_count, size_t max_count)
|
||||
{
|
||||
return as_2region_vector (r->selected_interacting_differential (other, min_count, max_count));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_interacting_with_edges (const db::Region *r, const db::Edges &other, size_t min_count, size_t max_count)
|
||||
{
|
||||
return as_2region_vector (r->selected_interacting_differential (other, min_count, max_count));
|
||||
}
|
||||
|
||||
static std::vector<db::Region> split_interacting_with_texts (const db::Region *r, const db::Texts &other, size_t min_count, size_t max_count)
|
||||
{
|
||||
return as_2region_vector (r->selected_interacting_differential (other, min_count, max_count));
|
||||
}
|
||||
|
||||
template <class Container>
|
||||
|
|
@ -681,6 +719,7 @@ int po_any ();
|
|||
|
||||
extern Class<db::ShapeCollection> decl_dbShapeCollection;
|
||||
|
||||
|
||||
Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
||||
constructor ("new", &new_v,
|
||||
"@brief Default constructor\n"
|
||||
|
|
@ -1616,7 +1655,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"This method has been introduced in version 0.27."
|
||||
) +
|
||||
method ("split_covering", &db::Region::selected_enclosing_differential, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
method_ext ("split_covering", &split_covering, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
"@brief Returns the polygons of this region which are completely covering polygons from the other region and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\covering, the second the result of \\not_covering\n"
|
||||
|
|
@ -1662,7 +1701,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"Merged semantics applies for this method (see \\merged_semantics= for a description of this concept)\n"
|
||||
) +
|
||||
method ("split_inside", &db::Region::selected_inside_differential, gsi::arg ("other"),
|
||||
method_ext ("split_inside", &split_inside, gsi::arg ("other"),
|
||||
"@brief Returns the polygons of this region which are completely inside polygons from the other region and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\inside, the second the result of \\not_inside\n"
|
||||
|
|
@ -1700,7 +1739,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"Merged semantics applies for this method (see \\merged_semantics= for a description of this concept)\n"
|
||||
) +
|
||||
method ("split_outside", &db::Region::selected_outside_differential, gsi::arg ("other"),
|
||||
method_ext ("split_outside", &split_outside, gsi::arg ("other"),
|
||||
"@brief Returns the polygons of this region which are completely outside polygons from the other region and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\outside, the second the result of \\not_outside\n"
|
||||
|
|
@ -1752,7 +1791,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The min_count and max_count arguments have been added in version 0.27.\n"
|
||||
) +
|
||||
method ("split_interacting", (std::pair<db::Region, db::Region> (db::Region::*) (const db::Region &, size_t, size_t) const) &db::Region::selected_interacting_differential, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
method_ext ("split_interacting", &split_interacting_with_region, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
"@brief Returns the polygons of this region which are interacting with polygons from the other region and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\interacting, the second the result of \\not_interacting\n"
|
||||
|
|
@ -1820,7 +1859,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"This method has been introduced in version 0.25\n"
|
||||
"The min_count and max_count arguments have been added in version 0.27.\n"
|
||||
) +
|
||||
method ("split_interacting", (std::pair<db::Region, db::Region> (db::Region::*) (const db::Edges &, size_t, size_t) const) &db::Region::selected_interacting_differential, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
method_ext ("split_interacting", &split_interacting_with_edges, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
"@brief Returns the polygons of this region which are interacting with edges from the other edge collection and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\interacting, the second the result of \\not_interacting\n"
|
||||
|
|
@ -1888,7 +1927,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"This method has been introduced in version 0.27\n"
|
||||
) +
|
||||
method ("split_interacting", (std::pair<db::Region, db::Region> (db::Region::*) (const db::Texts &, size_t, size_t) const) &db::Region::selected_interacting_differential, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
method_ext ("split_interacting", &split_interacting_with_texts, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
"@brief Returns the polygons of this region which are interacting with texts from the other text collection and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\interacting, the second the result of \\not_interacting\n"
|
||||
|
|
@ -1944,7 +1983,7 @@ Class<db::Region> decl_Region (decl_dbShapeCollection, "db", "Region",
|
|||
"\n"
|
||||
"The count options have been introduced in version 0.27."
|
||||
) +
|
||||
method ("split_overlapping", &db::Region::selected_overlapping_differential, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
method_ext ("split_overlapping", &split_overlapping, gsi::arg ("other"), gsi::arg ("min_count", size_t (1)), gsi::arg ("max_count", size_t (std::numeric_limits<size_t>::max ()), "unlimited"),
|
||||
"@brief Returns the polygons of this region which are overlapping with polygons from the other region and the ones which are not at the same time\n"
|
||||
"\n"
|
||||
"@return Two new regions: the first containing the result of \\overlapping, the second the result of \\not_overlapping\n"
|
||||
|
|
|
|||
|
|
@ -354,6 +354,8 @@ TEST(10a)
|
|||
r.set_merged_semantics (false);
|
||||
EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_not_interacting (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).first.to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Region (db::Box (db::Point (20, 20), db::Point (30, 30)))).second.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (db::compare (r.selected_interacting (db::Region (db::Box (db::Point (-20, -20), db::Point (30, 30)))), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
|
||||
EXPECT_EQ (r.selected_interacting (db::Region (db::Box (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
|
||||
db::Region rr = r;
|
||||
|
|
@ -836,6 +838,8 @@ TEST(18a)
|
|||
EXPECT_EQ (db::compare (o, "(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60)"), true);
|
||||
o = r;
|
||||
EXPECT_EQ (db::compare (o.selected_not_outside (rr), "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_outside_differential (rr).first, "(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_outside_differential (rr).second, "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (o.selected_outside (rr).count () + o.selected_not_outside (rr).count (), size_t (6));
|
||||
EXPECT_EQ (o.selected_outside (rr).hier_count () + o.selected_not_outside (rr).hier_count (), size_t (6));
|
||||
o.select_not_outside (rr);
|
||||
|
|
@ -848,6 +852,8 @@ TEST(18a)
|
|||
EXPECT_EQ (o.to_string (), "(20,30;20,50;40,50;40,30)");
|
||||
o = r;
|
||||
EXPECT_EQ (db::compare (o.selected_not_inside (rr), "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_inside_differential (rr).first, "(20,30;20,50;40,50;40,30)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_inside_differential (rr).second, "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (o.selected_inside (rr).count () + o.selected_not_inside (rr).count (), size_t (6));
|
||||
EXPECT_EQ (o.selected_inside (rr).hier_count () + o.selected_not_inside (rr).hier_count (), size_t (6));
|
||||
o.select_not_inside (rr);
|
||||
|
|
@ -860,6 +866,8 @@ TEST(18a)
|
|||
EXPECT_EQ (db::compare (o, "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
o = r;
|
||||
EXPECT_EQ (o.selected_not_interacting (rr).to_string (), "(70,60;70,80;90,80;90,60)");
|
||||
EXPECT_EQ (db::compare (o.selected_interacting_differential (rr).first, "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_interacting_differential (rr).second, "(70,60;70,80;90,80;90,60)"), true);
|
||||
EXPECT_EQ (o.selected_interacting (rr).count () + o.selected_not_interacting (rr).count (), size_t (6));
|
||||
EXPECT_EQ (o.selected_interacting (rr).hier_count () + o.selected_not_interacting (rr).hier_count (), size_t (6));
|
||||
o.select_not_interacting (rr);
|
||||
|
|
@ -872,6 +880,8 @@ TEST(18a)
|
|||
EXPECT_EQ (db::compare (o, "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
o = r;
|
||||
EXPECT_EQ (db::compare (o.selected_not_overlapping (rr), "(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_overlapping_differential (rr).first, "(0,0;0,20;20,20;20,0);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60);(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_overlapping_differential (rr).second, "(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60)"), true);
|
||||
EXPECT_EQ (o.selected_overlapping (rr).count () + o.selected_not_overlapping (rr).count (), size_t (6));
|
||||
EXPECT_EQ (o.selected_overlapping (rr).hier_count () + o.selected_not_overlapping (rr).hier_count (), size_t (6));
|
||||
o.select_not_overlapping (rr);
|
||||
|
|
@ -884,6 +894,8 @@ TEST(18a)
|
|||
EXPECT_EQ (o.to_string (), "(0,100;0,130;30,130;30,100)");
|
||||
o = r;
|
||||
EXPECT_EQ (db::compare (o.selected_not_enclosing (rr), "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_enclosing_differential (rr).first, "(0,100;0,130;30,130;30,100)"), true);
|
||||
EXPECT_EQ (db::compare (o.selected_enclosing_differential (rr).second, "(0,0;0,20;20,20;20,0);(50,10;50,30;70,30;70,10);(70,60;70,80;90,80;90,60);(20,30;20,50;40,50;40,30);(0,60;0,80;60,80;60,60)"), true);
|
||||
EXPECT_EQ (o.selected_enclosing (rr).count () + o.selected_not_enclosing (rr).count (), size_t (6));
|
||||
EXPECT_EQ (o.selected_enclosing (rr).hier_count () + o.selected_not_enclosing (rr).hier_count (), size_t (6));
|
||||
o.select_not_enclosing (rr);
|
||||
|
|
@ -1506,6 +1518,8 @@ TEST(30a)
|
|||
r.set_merged_semantics (false);
|
||||
EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_not_interacting (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).first.to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Edges (db::Edge (db::Point (20, 20), db::Point (30, 30)))).second.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (db::compare (r.selected_interacting (db::Edges (db::Edge (db::Point (-20, -20), db::Point (30, 30)))), "(-100,-100;-100,0;0,0;0,-100);(0,0;0,200;100,200;100,0)"), true);
|
||||
EXPECT_EQ (r.selected_interacting (db::Edges (db::Edge (db::Point (-200, -200), db::Point (-190, -190)))).to_string (), "");
|
||||
db::Region rr = r;
|
||||
|
|
@ -1689,6 +1703,8 @@ TEST(34a)
|
|||
r.set_merged_semantics (false);
|
||||
EXPECT_EQ (r.selected_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_not_interacting (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).first.to_string (), "(0,0;0,200;100,200;100,0)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (db::Texts (db::Text ("abc", db::Trans (db::Vector (30, 30))))).second.to_string (), "(-100,-100;-100,0;0,0;0,-100)");
|
||||
db::Texts tt;
|
||||
tt.insert (db::Text ("abc", db::Trans (db::Vector (30, 30))));
|
||||
tt.insert (db::Text ("xyz", db::Trans (db::Vector (-100, 0))));
|
||||
|
|
@ -1782,6 +1798,7 @@ TEST(35a_interact_with_count_region)
|
|||
EXPECT_EQ (r.selected_interacting (rr, 0, 2).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 1, 4).first.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
|
|
@ -1797,6 +1814,7 @@ TEST(35a_interact_with_count_region)
|
|||
EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 1, 2).second.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
|
||||
EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
|
||||
|
|
@ -1855,6 +1873,7 @@ TEST(35b_interact_with_count_edge)
|
|||
EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 2, 4).first.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
|
|
@ -1869,6 +1888,7 @@ TEST(35b_interact_with_count_edge)
|
|||
EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 1, 2).second.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
|
||||
EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
|
||||
|
|
@ -1926,6 +1946,7 @@ TEST(35c_interact_with_count_text)
|
|||
EXPECT_EQ (r.selected_interacting (rr, 1, 2).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 1, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 2, 4).first.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 2, 1).to_string (), "");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 3, 4).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting (rr, 4, 5).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
|
|
@ -1940,6 +1961,7 @@ TEST(35c_interact_with_count_text)
|
|||
EXPECT_EQ (r.selected_not_interacting (rr).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 0, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 2).to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_interacting_differential (rr, 1, 2).second.to_string (), "(-100,-100;-100,0;0,0;0,200;100,200;100,0;0,0;0,-100)");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 1, 4).to_string (), "");
|
||||
EXPECT_EQ (r.selected_not_interacting (rr, 2, 4).to_string (), "");
|
||||
EXPECT_EQ (db::compare (r.selected_not_interacting (rr, 2, 1), "(0,0;0,200;100,200;100,0);(-100,-100;-100,0;0,0;0,-100)"), true);
|
||||
|
|
|
|||
|
|
@ -1660,6 +1660,7 @@ CODE
|
|||
|
||||
@engine._context("andnot") do
|
||||
|
||||
check_is_layer(other)
|
||||
requires_region
|
||||
other.requires_region
|
||||
|
||||
|
|
@ -1776,14 +1777,17 @@ CODE
|
|||
# %DRC%
|
||||
# @name split_covering
|
||||
# @brief Returns the results of \covering and \not_covering at the same time
|
||||
# @synopsis (a, b) = layer.split_covering(other [, options ])
|
||||
#
|
||||
# This method returns the polygons covering polygons from the other layer in
|
||||
# one layer and all others in a second layer. This method is equivalent to calling
|
||||
# \covering and \not_covering, but is faster than doing this is separate steps:
|
||||
# \covering and \not_covering, but is faster than doing this in separate steps:
|
||||
#
|
||||
# @code
|
||||
# (covering, not_covering) = l1.split_covering(l2)
|
||||
# @/code
|
||||
#
|
||||
# The options of this method are the same than \covering.
|
||||
|
||||
# %DRC%
|
||||
# @name select_covering
|
||||
|
|
@ -1864,14 +1868,17 @@ CODE
|
|||
# %DRC%
|
||||
# @name split_overlapping
|
||||
# @brief Returns the results of \overlapping and \not_overlapping at the same time
|
||||
# @synopsis (a, b) = layer.split_overlapping(other [, options ])
|
||||
#
|
||||
# This method returns the polygons overlapping polygons from the other layer in
|
||||
# one layer and all others in a second layer. This method is equivalent to calling
|
||||
# \overlapping and \not_overlapping, but is faster than doing this is separate steps:
|
||||
# \overlapping and \not_overlapping, but is faster than doing this in separate steps:
|
||||
#
|
||||
# @code
|
||||
# (overlapping, not_overlapping) = l1.split_overlapping(l2)
|
||||
# @/code
|
||||
#
|
||||
# The options of this method are the same than \overlapping.
|
||||
|
||||
# %DRC%
|
||||
# @name select_overlapping
|
||||
|
|
@ -1950,10 +1957,11 @@ CODE
|
|||
# %DRC%
|
||||
# @name split_inside
|
||||
# @brief Returns the results of \inside and \not_inside at the same time
|
||||
# @synopsis (a, b) = layer.split_inside(other)
|
||||
#
|
||||
# This method returns the polygons inside of polygons from the other layer in
|
||||
# one layer and all others in a second layer. This method is equivalent to calling
|
||||
# \inside and \not_inside, but is faster than doing this is separate steps:
|
||||
# \inside and \not_inside, but is faster than doing this in separate steps:
|
||||
#
|
||||
# @code
|
||||
# (inside, not_inside) = l1.split_inside(l2)
|
||||
|
|
@ -2034,10 +2042,11 @@ CODE
|
|||
# %DRC%
|
||||
# @name split_outside
|
||||
# @brief Returns the results of \outside and \not_outside at the same time
|
||||
# @synopsis (a, b) = layer.split_outside(other)
|
||||
#
|
||||
# This method returns the polygons outside of polygons from the other layer in
|
||||
# one layer and all others in a second layer. This method is equivalent to calling
|
||||
# \outside and \not_outside, but is faster than doing this is separate steps:
|
||||
# \outside and \not_outside, but is faster than doing this in separate steps:
|
||||
#
|
||||
# @code
|
||||
# (outside, not_outside) = l1.split_outside(l2)
|
||||
|
|
@ -2200,14 +2209,17 @@ CODE
|
|||
# %DRC%
|
||||
# @name split_interacting
|
||||
# @brief Returns the results of \interacting and \not_interacting at the same time
|
||||
# @synopsis (a, b) = layer.split_interacting(other [, options ])
|
||||
#
|
||||
# This method returns the polygons interacting with objects from the other container in
|
||||
# one layer and all others in a second layer. This method is equivalent to calling
|
||||
# \interacting and \not_interacting, but is faster than doing this is separate steps:
|
||||
# \interacting and \not_interacting, but is faster than doing this in separate steps:
|
||||
#
|
||||
# @code
|
||||
# (interacting, not_interacting) = l1.split_interacting(l2)
|
||||
# @/code
|
||||
#
|
||||
# The options of this method are the same than \interacting.
|
||||
|
||||
# %DRC%
|
||||
# @name select_interacting
|
||||
|
|
@ -2345,6 +2357,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
if :#{f} != :pull_interacting
|
||||
requires_region
|
||||
other.requires_region
|
||||
|
|
@ -2390,6 +2403,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
other.requires_edges_texts_or_region
|
||||
if self.data.is_a?(RBA::Texts)
|
||||
other.requires_region
|
||||
|
|
@ -2426,6 +2440,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
if self.data.is_a?(RBA::Text)
|
||||
other.requires_region
|
||||
elsif self.data.is_a?(RBA::Region)
|
||||
|
|
@ -2450,6 +2465,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
requires_edges_texts_or_region
|
||||
if self.data.is_a?(RBA::Text)
|
||||
other.requires_region
|
||||
|
|
@ -2478,6 +2494,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
requires_region
|
||||
other.requires_edges_texts_or_region
|
||||
|
||||
|
|
@ -2580,6 +2597,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
requires_region
|
||||
other.requires_region
|
||||
|
||||
|
|
@ -2598,6 +2616,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
other.requires_region
|
||||
requires_edges
|
||||
|
||||
|
|
@ -2615,6 +2634,7 @@ CODE
|
|||
|
||||
@engine._context("#{f}") do
|
||||
|
||||
check_is_layer(other)
|
||||
other.requires_edges
|
||||
requires_edges
|
||||
|
||||
|
|
@ -4230,6 +4250,10 @@ CODE
|
|||
@data = d
|
||||
end
|
||||
|
||||
def check_is_layer(other)
|
||||
other.is_a?(DRCLayer) || raise("Argument needs to be a DRC layer")
|
||||
end
|
||||
|
||||
def requires_region
|
||||
self.data.is_a?(RBA::Region) || raise("Requires a polygon layer")
|
||||
end
|
||||
|
|
|
|||
|
|
@ -2659,6 +2659,87 @@ The following image shows the effect of the space check:
|
|||
</tr>
|
||||
</table>
|
||||
</p>
|
||||
<a name="split_covering"/><h2>"split_covering" - Returns the results of <a href="#covering">covering</a> and <a href="#not_covering">not_covering</a> at the same time</h2>
|
||||
<keyword name="split_covering"/>
|
||||
<p>Usage:</p>
|
||||
<ul>
|
||||
<li><tt>(a, b) = layer.split_covering(other [, options ])</tt></li>
|
||||
</ul>
|
||||
<p>
|
||||
This method returns the polygons covering polygons from the other layer in
|
||||
one layer and all others in a second layer. This method is equivalent to calling
|
||||
<a href="#covering">covering</a> and <a href="#not_covering">not_covering</a>, but is faster than doing this in separate steps:
|
||||
</p><p>
|
||||
<pre>
|
||||
(covering, not_covering) = l1.split_covering(l2)
|
||||
</pre>
|
||||
</p><p>
|
||||
The options of this method are the same than <a href="#covering">covering</a>.
|
||||
</p>
|
||||
<a name="split_inside"/><h2>"split_inside" - Returns the results of <a href="#inside">inside</a> and <a href="#not_inside">not_inside</a> at the same time</h2>
|
||||
<keyword name="split_inside"/>
|
||||
<p>Usage:</p>
|
||||
<ul>
|
||||
<li><tt>(a, b) = layer.split_inside(other)</tt></li>
|
||||
</ul>
|
||||
<p>
|
||||
This method returns the polygons inside of polygons from the other layer in
|
||||
one layer and all others in a second layer. This method is equivalent to calling
|
||||
<a href="#inside">inside</a> and <a href="#not_inside">not_inside</a>, but is faster than doing this in separate steps:
|
||||
</p><p>
|
||||
<pre>
|
||||
(inside, not_inside) = l1.split_inside(l2)
|
||||
</pre>
|
||||
</p>
|
||||
<a name="split_interacting"/><h2>"split_interacting" - Returns the results of <a href="#interacting">interacting</a> and <a href="#not_interacting">not_interacting</a> at the same time</h2>
|
||||
<keyword name="split_interacting"/>
|
||||
<p>Usage:</p>
|
||||
<ul>
|
||||
<li><tt>(a, b) = layer.split_interacting(other [, options ])</tt></li>
|
||||
</ul>
|
||||
<p>
|
||||
This method returns the polygons interacting with objects from the other container in
|
||||
one layer and all others in a second layer. This method is equivalent to calling
|
||||
<a href="#interacting">interacting</a> and <a href="#not_interacting">not_interacting</a>, but is faster than doing this in separate steps:
|
||||
</p><p>
|
||||
<pre>
|
||||
(interacting, not_interacting) = l1.split_interacting(l2)
|
||||
</pre>
|
||||
</p><p>
|
||||
The options of this method are the same than <a href="#interacting">interacting</a>.
|
||||
</p>
|
||||
<a name="split_outside"/><h2>"split_outside" - Returns the results of <a href="#outside">outside</a> and <a href="#not_outside">not_outside</a> at the same time</h2>
|
||||
<keyword name="split_outside"/>
|
||||
<p>Usage:</p>
|
||||
<ul>
|
||||
<li><tt>(a, b) = layer.split_outside(other)</tt></li>
|
||||
</ul>
|
||||
<p>
|
||||
This method returns the polygons outside of polygons from the other layer in
|
||||
one layer and all others in a second layer. This method is equivalent to calling
|
||||
<a href="#outside">outside</a> and <a href="#not_outside">not_outside</a>, but is faster than doing this in separate steps:
|
||||
</p><p>
|
||||
<pre>
|
||||
(outside, not_outside) = l1.split_outside(l2)
|
||||
</pre>
|
||||
</p>
|
||||
<a name="split_overlapping"/><h2>"split_overlapping" - Returns the results of <a href="#overlapping">overlapping</a> and <a href="#not_overlapping">not_overlapping</a> at the same time</h2>
|
||||
<keyword name="split_overlapping"/>
|
||||
<p>Usage:</p>
|
||||
<ul>
|
||||
<li><tt>(a, b) = layer.split_overlapping(other [, options ])</tt></li>
|
||||
</ul>
|
||||
<p>
|
||||
This method returns the polygons overlapping polygons from the other layer in
|
||||
one layer and all others in a second layer. This method is equivalent to calling
|
||||
<a href="#overlapping">overlapping</a> and <a href="#not_overlapping">not_overlapping</a>, but is faster than doing this in separate steps:
|
||||
</p><p>
|
||||
<pre>
|
||||
(overlapping, not_overlapping) = l1.split_overlapping(l2)
|
||||
</pre>
|
||||
</p><p>
|
||||
The options of this method are the same than <a href="#overlapping">overlapping</a>.
|
||||
</p>
|
||||
<a name="squares"/><h2>"squares" - Selects all squares from the input</h2>
|
||||
<keyword name="squares"/>
|
||||
<p>Usage:</p>
|
||||
|
|
|
|||
|
|
@ -12,6 +12,18 @@ l2 = input(2, 0)
|
|||
l1.output(1, 0)
|
||||
l2.output(2, 0)
|
||||
|
||||
def split_vs_normal(r, f1, f2, *args)
|
||||
d1 = r.send(f1, *args)[0].data
|
||||
d2 = r.send(f2, *args).data
|
||||
d1.to_s == d2.to_s || raise("#{f1.to_s} vs. #{f2.to_s} check failed: #{d1.to_s} != #{d2.to_s}")
|
||||
end
|
||||
|
||||
def splitn_vs_normal(r, f1, f2, *args)
|
||||
d1 = r.send(f1, *args)[1].data
|
||||
d2 = r.send(f2, *args).data
|
||||
d1.to_s == d2.to_s || raise("#{f1.to_s} vs. #{f2.to_s} check failed: #{d1.to_s} != #{d2.to_s}")
|
||||
end
|
||||
|
||||
l1.interacting(l2, 1).output(100, 0)
|
||||
l1.interacting(l2, 2).output(101, 0)
|
||||
l1.interacting(l2, 1..2).output(102, 0)
|
||||
|
|
@ -22,6 +34,11 @@ else
|
|||
end
|
||||
l1.interacting(l2, 1, 2).output(104, 0)
|
||||
|
||||
split_vs_normal(l1, :split_interacting, :interacting, l2, 1)
|
||||
split_vs_normal(l1, :split_interacting, :interacting, l2, 2)
|
||||
split_vs_normal(l1, :split_interacting, :interacting, l2, 1..2)
|
||||
split_vs_normal(l1, :split_interacting, :interacting, l2, 1, 2)
|
||||
|
||||
l1.overlapping(l2, 1).output(110, 0)
|
||||
l1.overlapping(l2, 2).output(111, 0)
|
||||
l1.overlapping(l2, 1..2).output(112, 0)
|
||||
|
|
@ -32,6 +49,11 @@ else
|
|||
end
|
||||
l1.overlapping(l2, 1, 2).output(114, 0)
|
||||
|
||||
split_vs_normal(l1, :split_overlapping, :overlapping, l2, 1)
|
||||
split_vs_normal(l1, :split_overlapping, :overlapping, l2, 2)
|
||||
split_vs_normal(l1, :split_overlapping, :overlapping, l2, 1..2)
|
||||
split_vs_normal(l1, :split_overlapping, :overlapping, l2, 1, 2)
|
||||
|
||||
l = l1.dup
|
||||
l.select_interacting(l2, 1)
|
||||
l.output(200, 0)
|
||||
|
|
@ -82,6 +104,11 @@ else
|
|||
end
|
||||
l1.not_interacting(l2, 1, 2).output(304, 0)
|
||||
|
||||
splitn_vs_normal(l1, :split_interacting, :not_interacting, l2, 1)
|
||||
splitn_vs_normal(l1, :split_interacting, :not_interacting, l2, 2)
|
||||
splitn_vs_normal(l1, :split_interacting, :not_interacting, l2, 1..2)
|
||||
splitn_vs_normal(l1, :split_interacting, :not_interacting, l2, 1, 2)
|
||||
|
||||
l1.not_overlapping(l2, 1).output(310, 0)
|
||||
l1.not_overlapping(l2, 2).output(311, 0)
|
||||
l1.not_overlapping(l2, 1..2).output(312, 0)
|
||||
|
|
@ -92,6 +119,11 @@ else
|
|||
end
|
||||
l1.not_overlapping(l2, 1, 2).output(314, 0)
|
||||
|
||||
splitn_vs_normal(l1, :split_overlapping, :not_overlapping, l2, 1)
|
||||
splitn_vs_normal(l1, :split_overlapping, :not_overlapping, l2, 2)
|
||||
splitn_vs_normal(l1, :split_overlapping, :not_overlapping, l2, 1..2)
|
||||
splitn_vs_normal(l1, :split_overlapping, :not_overlapping, l2, 1, 2)
|
||||
|
||||
l = l1.dup
|
||||
l.select_not_interacting(l2, 1)
|
||||
l.output(400, 0)
|
||||
|
|
|
|||
|
|
@ -10,11 +10,33 @@ b = input(2, 0)
|
|||
a.output(1, 0)
|
||||
b.output(2, 0)
|
||||
|
||||
def split_vs_normal(r, f1, f2, *args)
|
||||
d1 = r.send(f1, *args)[0].data
|
||||
d2 = r.send(f2, *args).data
|
||||
d1.to_s == d2.to_s || raise("#{f1.to_s} vs. #{f2.to_s} check failed: #{d1.to_s} != #{d2.to_s}")
|
||||
end
|
||||
|
||||
def splitn_vs_normal(r, f1, f2, *args)
|
||||
d1 = r.send(f1, *args)[1].data
|
||||
d2 = r.send(f2, *args).data
|
||||
d1.to_s == d2.to_s || raise("#{f1.to_s} vs. #{f2.to_s} check failed: #{d1.to_s} != #{d2.to_s}")
|
||||
end
|
||||
|
||||
a.covering(b).output(100, 0)
|
||||
a.covering(b, 1..1).output(101, 0)
|
||||
a.covering(b, 2..2).output(102, 0)
|
||||
a.covering(b, 3..3).output(103, 0)
|
||||
b.inside(a).output(110, 0)
|
||||
a.not_covering(b).output(120, 0)
|
||||
b.not_inside(a).output(130, 0)
|
||||
|
||||
split_vs_normal(a, :split_covering, :covering, b)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 1..1)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 2..2)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 3..3)
|
||||
split_vs_normal(b, :split_inside, :inside, a)
|
||||
splitn_vs_normal(a, :split_covering, :not_covering, b)
|
||||
splitn_vs_normal(b, :split_inside, :not_inside, a)
|
||||
|
||||
deep
|
||||
|
||||
|
|
@ -26,4 +48,14 @@ a.covering(b, 1..1).output(201, 0)
|
|||
a.covering(b, 2..2).output(202, 0)
|
||||
a.covering(b, 3..3).output(203, 0)
|
||||
b.inside(a).output(210, 0)
|
||||
a.not_covering(b).output(220, 0)
|
||||
b.not_inside(a).output(230, 0)
|
||||
|
||||
split_vs_normal(a, :split_covering, :covering, b)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 1..1)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 2..2)
|
||||
split_vs_normal(a, :split_covering, :covering, b, 3..3)
|
||||
split_vs_normal(b, :split_inside, :inside, a)
|
||||
splitn_vs_normal(a, :split_covering, :not_covering, b)
|
||||
splitn_vs_normal(b, :split_inside, :not_inside, a)
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -148,6 +148,7 @@ def run_testsuite(dm, ic, tiled = false, hier = false)
|
|||
b.not_interacting(a).output(lb, dm + 1)
|
||||
b.interacting(empty).output(lb, dm + 2)
|
||||
b.not_interacting(empty).output(lb, dm + 3)
|
||||
|
||||
b.interacting(a).in(b).output(lb + 1, dm)
|
||||
(b|a).not_in(b).output(lb + 2, dm)
|
||||
x.in(b).output(lb + 3, dm)
|
||||
|
|
@ -160,18 +161,42 @@ def run_testsuite(dm, ic, tiled = false, hier = false)
|
|||
b.not_inside(c).output(lb, dm + 1)
|
||||
b.inside(empty).output(lb, dm + 2)
|
||||
b.not_inside(empty).output(lb, dm + 3)
|
||||
(p, m) = b.split_inside(c)
|
||||
p.output(lb, dm + 10)
|
||||
m.output(lb, dm + 11)
|
||||
|
||||
b.covering(c).output(lb, dm + 100)
|
||||
b.not_covering(c).output(lb, dm + 101)
|
||||
b.covering(empty).output(lb, dm + 102)
|
||||
b.not_covering(empty).output(lb, dm + 103)
|
||||
(p, m) = b.split_covering(c)
|
||||
p.output(lb, dm + 110)
|
||||
m.output(lb, dm + 111)
|
||||
|
||||
b.outside(c).output(lb + 1, dm)
|
||||
b.not_outside(c).output(lb + 1, dm + 1)
|
||||
b.outside(empty).output(lb + 1, dm + 2)
|
||||
b.not_outside(empty).output(lb + 1, dm + 3)
|
||||
(p, m) = b.split_outside(c)
|
||||
p.output(lb + 1, dm + 10)
|
||||
m.output(lb + 1, dm + 11)
|
||||
|
||||
b.overlapping(c).output(lb + 2, dm)
|
||||
b.not_overlapping(c).output(lb + 2, dm + 1)
|
||||
b.overlapping(empty).output(lb + 2, dm + 2)
|
||||
b.not_overlapping(empty).output(lb + 2, dm + 3)
|
||||
(p, m) = b.split_overlapping(c)
|
||||
p.output(lb + 2, dm + 10)
|
||||
m.output(lb + 2, dm + 11)
|
||||
|
||||
b.interacting(c).output(lb + 3, dm)
|
||||
b.not_interacting(c).output(lb + 3, dm + 1)
|
||||
b.interacting(empty).output(lb + 3, dm + 2)
|
||||
b.not_interacting(empty).output(lb + 3, dm + 3)
|
||||
(p, m) = b.split_interacting(c)
|
||||
p.output(lb + 3, dm + 10)
|
||||
m.output(lb + 3, dm + 11)
|
||||
|
||||
bdup = b.dup
|
||||
bdup.select_inside(c)
|
||||
bdup.xor(b.inside(c)).output(lb + 4, dm)
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -525,34 +525,49 @@ class DBRegion_TestClass < TestBase
|
|||
|
||||
r1 = RBA::Region::new
|
||||
r1.insert(RBA::Box::new(10, 20, 100, 200))
|
||||
r11 = r1.dup
|
||||
r1.insert(RBA::Box::new(50, 70, 150, 270))
|
||||
r1.insert(RBA::Box::new(100, 70, 250, 270))
|
||||
r2 = RBA::Region::new(RBA::Box::new(-10, -20, 100, 200))
|
||||
r3 = RBA::Region::new(RBA::Box::new(150, 270, 160, 280))
|
||||
r3 += r2
|
||||
r21 = r2.dup
|
||||
r21 += RBA::Region::new(RBA::Box::new(110, -20, 200, 200))
|
||||
|
||||
assert_equal(r1.merged_semantics?, true)
|
||||
r1.merged_semantics = false
|
||||
assert_equal(r1.merged_semantics?, false)
|
||||
|
||||
assert_equal(r1.inside(r2).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(r1.split_inside(r2)[0].to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.not_inside(r2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(csort(r1.split_inside(r2)[1].to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(r21.covering(r11).to_s, "(-10,-20;-10,200;100,200;100,-20)")
|
||||
assert_equal(r21.split_covering(r11)[0].to_s, "(-10,-20;-10,200;100,200;100,-20)")
|
||||
assert_equal(csort(r21.not_covering(r11).to_s), csort("(110,-20;110,200;200,200;200,-20)"))
|
||||
assert_equal(csort(r21.split_covering(r11)[1].to_s), csort("(110,-20;110,200;200,200;200,-20)"))
|
||||
assert_equal(csort(r1.interacting(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(csort(r1.interacting(r3, 1).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(csort(r1.interacting(r3, 2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(csort(r1.split_interacting(r3, 2)[0].to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(r1.interacting(r3, 3).to_s, "")
|
||||
assert_equal(r1.interacting(r3, 1, 1).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.interacting(r3, 2, 2).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(r1.not_interacting(r2).to_s, "")
|
||||
assert_equal(r1.not_interacting(r3, 1).to_s, "")
|
||||
assert_equal(r1.not_interacting(r3, 2).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(r1.split_interacting(r3, 2)[1].to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.not_interacting(r3, 3).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(csort(r1.not_interacting(r3, 1, 1).to_s), csort("(50,70;50,270;150,270;150,70);(100,70;100,270;250,270;250,70)"))
|
||||
assert_equal(r1.not_interacting(r3, 2, 2).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.overlapping(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(csort(r1.split_overlapping(r2)[0].to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(r1.not_overlapping(r2).to_s, "(100,70;100,270;250,270;250,70)")
|
||||
assert_equal(r1.split_overlapping(r2)[1].to_s, "(100,70;100,270;250,270;250,70)")
|
||||
assert_equal(r1.outside(r2).to_s, "(100,70;100,270;250,270;250,70)")
|
||||
assert_equal(r1.split_outside(r2)[0].to_s, "(100,70;100,270;250,270;250,70)")
|
||||
assert_equal(csort(r1.not_outside(r2).to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(csort(r1.split_outside(r2)[1].to_s), csort("(10,20;10,200;100,200;100,20);(50,70;50,270;150,270;150,70)"))
|
||||
|
||||
e2 = RBA::Edges::new(RBA::Edge::new(-10, -20, 100, 200))
|
||||
e3 = RBA::Edges::new(RBA::Edge::new(150, 270, 160, 280))
|
||||
|
|
@ -561,12 +576,14 @@ class DBRegion_TestClass < TestBase
|
|||
assert_equal(csort(r1.interacting(e2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.interacting(e3, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.interacting(e3, 2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(csort(r1.split_interacting(e3, 2)[0].to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(r1.interacting(e3, 3).to_s, "")
|
||||
assert_equal(r1.interacting(e3, 1, 1).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.interacting(e3, 2, 2).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(r1.not_interacting(e2).to_s, "")
|
||||
assert_equal(r1.not_interacting(e3, 1).to_s, "")
|
||||
assert_equal(r1.not_interacting(e3, 2).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(r1.split_interacting(e3, 2)[1].to_s, "(10,20;10,200;100,200;100,20)")
|
||||
assert_equal(csort(r1.not_interacting(e3, 3).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.not_interacting(e3, 1, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70)"))
|
||||
assert_equal(r1.not_interacting(e3, 2, 2).to_s, "(10,20;10,200;100,200;100,20)")
|
||||
|
|
@ -577,6 +594,7 @@ class DBRegion_TestClass < TestBase
|
|||
|
||||
assert_equal(csort(r1.interacting(t2).to_s), csort("(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.interacting(t3, 1).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.split_interacting(t3, 1)[0].to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(r1.interacting(t3, 2).to_s, "(50,70;50,270;150,270;150,70)")
|
||||
assert_equal(r1.interacting(t3, 3).to_s, "")
|
||||
assert_equal(csort(r1.interacting(t3, 1, 1).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
|
||||
|
|
@ -584,6 +602,7 @@ class DBRegion_TestClass < TestBase
|
|||
assert_equal(r1.not_interacting(t2).to_s, "(100,70;100,270;250,270;250,70)")
|
||||
assert_equal(r1.not_interacting(t3, 1).to_s, "")
|
||||
assert_equal(csort(r1.not_interacting(t3, 2).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.split_interacting(t3, 2)[1].to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(csort(r1.not_interacting(t3, 3).to_s), csort("(100,70;100,270;250,270;250,70);(50,70;50,270;150,270;150,70);(10,20;10,200;100,200;100,20)"))
|
||||
assert_equal(r1.not_interacting(t3, 1, 1).to_s, "(50,70;50,270;150,270;150,70)")
|
||||
assert_equal(csort(r1.not_interacting(t3, 2, 2).to_s), csort("(100,70;100,270;250,270;250,70);(10,20;10,200;100,200;100,20)"))
|
||||
|
|
|
|||
Loading…
Reference in New Issue