mirror of https://github.com/KLayout/klayout.git
883 lines
28 KiB
Plaintext
883 lines
28 KiB
Plaintext
|
|
def message(m)
|
|
$stdout.puts(m)
|
|
$stdout.flush
|
|
end
|
|
|
|
def expect_eq(a, b)
|
|
a == b || raise("unexpected value #{a.to_s}, should be #{b.to_s}")
|
|
end
|
|
|
|
def run_testsuite(dm, ic, tiled = false, hier = false)
|
|
|
|
has_float_range = ((0..0.5).max != 0)
|
|
|
|
lb = 100
|
|
|
|
a = polygons(RBA::LayerInfo::new(1, 0))
|
|
at = labels(1)
|
|
b = polygons(2)
|
|
c = polygons(3)
|
|
d = polygons(4)
|
|
x = polygons(10)
|
|
y = polygons(11)
|
|
empty = polygons(1000)
|
|
|
|
h = {}
|
|
layers.each { |l| h[l] = true }
|
|
h[RBA::LayerInfo::new(1, 0)] || raise("missing layer 1/0 in layers list")
|
|
|
|
expect_eq(c.is_merged?, false)
|
|
|
|
message "--- general #{lb}"
|
|
|
|
l1 = a & b
|
|
l1.output(lb, dm)
|
|
expect_eq(l1.is_empty?, false)
|
|
|
|
(an1, an2) = a.andnot(b)
|
|
an1.output(lb, dm + 1)
|
|
expect_eq(an1.is_empty?, false)
|
|
|
|
a.and(b).xor(l1).is_empty? || raise("xor not empty")
|
|
tiled || hier || expect_eq(a.and(b).is_merged?, true)
|
|
|
|
a.xor(b).output(RBA::LayerInfo::new(lb + 1, dm))
|
|
a.xor(b).xor(a ^ b).is_empty? || raise("xor not empty")
|
|
a.not(b).output(lb + 2, dm)
|
|
an2.output(lb + 2, dm + 1)
|
|
a.not(b).xor(a - b).is_empty? || raise("xor not empty")
|
|
a.or(b).output(lb + 3, dm)
|
|
a.or(b).xor(a | b).is_empty? || raise("xor not empty")
|
|
|
|
a.join(b).output(lb + 4, dm)
|
|
a.join(b).xor(a + b).is_empty? || raise("xor not empty")
|
|
|
|
if !tiled
|
|
expect_eq(a.join(b).data.size, 17 * ic)
|
|
end
|
|
|
|
# NOTE: there is no clean/raw semantics in deep mode
|
|
if ! hier
|
|
expect_eq(c.raw.is_clean?, false)
|
|
# c.raw switched the semantics
|
|
expect_eq(c.is_clean?, false)
|
|
expect_eq((c.area / ic).to_s, "10.0")
|
|
expect_eq((c.edges.length / ic).to_s, "18.0")
|
|
expect_eq((c.perimeter / ic).to_s, "18.0")
|
|
c.clean
|
|
expect_eq(c.is_clean?, true)
|
|
end
|
|
|
|
expect_eq((c.area / ic).to_s, "9.0")
|
|
expect_eq((c.edges.length / ic).to_s, "14.0")
|
|
expect_eq((c.perimeter / ic).to_s, "14.0")
|
|
expect_eq((c.dup.area / ic).to_s, "9.0")
|
|
|
|
# NOTE: there is no clean/raw semantics in deep mode
|
|
if ! hier
|
|
expect_eq((c.raw.clean.area / ic).to_s, "9.0")
|
|
expect_eq((c.area / ic).to_s, "9.0")
|
|
expect_eq((c.raw.area / ic).to_s, "10.0")
|
|
c.clean
|
|
end
|
|
|
|
if ic == 1
|
|
expect_eq(c.bbox.to_s, "(-4,-5;0,-2)")
|
|
end
|
|
|
|
lb += 10 #110
|
|
message "--- centers, start_segments, end_segments #{lb}"
|
|
|
|
a.edges.centers(0.1).extended_out(0.01).output(lb, dm)
|
|
a.edges.centers(0, 0.5).extended_out(0.01).output(lb + 1, dm)
|
|
a.edges.centers(0.5, 0.5).extended_out(0.01).output(lb + 2, dm)
|
|
a.edges.start_segments(0.1).extended_out(0.01).output(lb + 3, dm)
|
|
a.edges.start_segments(0, 0.5).extended_out(0.01).output(lb + 4, dm)
|
|
a.edges.start_segments(0.5, 0.5).extended_out(0.01).output(lb + 5, dm)
|
|
a.edges.end_segments(0.1).extended_out(0.01).output(lb + 6, dm)
|
|
a.edges.end_segments(0, 0.5).extended_out(0.01).output(lb + 7, dm)
|
|
a.edges.end_segments(0.5, 0.5).extended_out(0.01).output(lb + 8, dm)
|
|
|
|
expect_eq(a.polygons?, true)
|
|
expect_eq(a.edges?, false)
|
|
expect_eq(a.edge_pairs?, false)
|
|
expect_eq(a.edges.edge_pairs?, false)
|
|
expect_eq(a.edges.polygons?, false)
|
|
expect_eq(a.edges.edges?, true)
|
|
expect_eq(a.space(0.5).edge_pairs?, true)
|
|
expect_eq(a.space(0.5).polygons?, false)
|
|
expect_eq(a.space(0.5).edges?, false)
|
|
|
|
lb += 10 #120
|
|
message "--- extended #{lb}"
|
|
|
|
a.edges.with_length(0.6).extended(:begin => 0.1, :end => 0.15, :out => 0.1, :in => -0.05).output(lb, dm)
|
|
a.edges.with_length(0.6).extended(:out => 0.1, :in => -0.05).output(lb + 1, dm)
|
|
a.edges.with_length(0..0.7).extended(:out => 0.1, :in => -0.05).output(lb + 2, dm)
|
|
a.edges.with_length(0..0.7).extended(:out => 0.1, :in => -0.05, :joined => true).output(lb + 3, dm)
|
|
a.edges.with_length(0..0.7).extended(:begin => 0.1, :end => 0.15, :out => 0.1, :in => 0.05, :joined => true).output(lb + 4, dm)
|
|
a.edges.with_length(0..0.7).extended(0.1, 0.15, 0.1, 0.05).output(lb + 5, dm)
|
|
a.edges.with_length(0..0.7).extended(0.1, 0.15, 0.1, 0.05, true).output(lb + 6, dm)
|
|
a.edges.with_length(0..0.7).extended_out(0.1).output(lb + 7, dm)
|
|
a.edges.with_length(0..0.7).extended_in(0.1).output(lb + 8, dm)
|
|
|
|
lb += 10 #130
|
|
message "--- extents #{lb}"
|
|
|
|
b.extents.output(lb, dm)
|
|
|
|
lb += 10 #140
|
|
message "--- first_edges, second_edges, edges #{lb}"
|
|
|
|
a.enclosing(b, 0.5, whole_edges).first_edges.extended_out(0.01).output(lb, dm)
|
|
a.enclosing(b, 0.5, whole_edges).second_edges.extended_out(0.01).output(lb + 1, dm)
|
|
a.enclosing(b, 0.5, whole_edges).edges.extended_out(0.01).output(lb + 2, dm)
|
|
|
|
b.enclosed(a, 0.5, whole_edges).second_edges.extended_out(0.01).output(lb + 3, dm)
|
|
b.enclosed(a, 0.5, whole_edges).first_edges.extended_out(0.01).output(lb + 4, dm)
|
|
b.enclosed(a, 0.5, whole_edges).edges.extended_out(0.01).output(lb + 5, dm)
|
|
|
|
lb += 10 #150
|
|
message "--- hulls, holes #{lb}"
|
|
|
|
c.xor(b).holes.output(lb, dm)
|
|
c.xor(b).hulls.output(lb + 1, dm)
|
|
c.xor(b).xor(c.xor(b).hulls - c.xor(b).holes).is_empty? || raise("xor not empty")
|
|
|
|
lb += 10 #160
|
|
message "--- interacting, in, not_in #{lb}"
|
|
|
|
b.interacting(a).output(lb, dm)
|
|
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)
|
|
expect_eq(b.sized(0.1).in(b).is_empty?, true)
|
|
|
|
lb += 10 #170
|
|
message "--- inside, outside, overlapping, interacting #{lb}"
|
|
|
|
b.inside(c).output(lb, dm)
|
|
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.edges.inside(c).output(lb, dm + 20)
|
|
b.edges.not_inside(c).output(lb, dm + 21)
|
|
b.edges.inside(empty).output(lb, dm + 22)
|
|
b.edges.not_inside(empty).output(lb, dm + 23)
|
|
(p, m) = b.edges.split_inside(c)
|
|
p.output(lb, dm + 30)
|
|
m.output(lb, dm + 31)
|
|
|
|
b.edges.inside(c.edges).output(lb, dm + 40)
|
|
b.edges.not_inside(c.edges).output(lb, dm + 41)
|
|
b.edges.inside(empty.edges).output(lb, dm + 42)
|
|
b.edges.not_inside(empty.edges).output(lb, dm + 43)
|
|
(p, m) = b.edges.split_inside(c.edges)
|
|
p.output(lb, dm + 50)
|
|
m.output(lb, dm + 51)
|
|
|
|
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.edges.outside(c).output(lb + 1, dm + 20)
|
|
b.edges.not_outside(c).output(lb + 1, dm + 21)
|
|
b.edges.outside(empty).output(lb + 1, dm + 22)
|
|
b.edges.not_outside(empty).output(lb + 1, dm + 23)
|
|
(p, m) = b.edges.split_outside(c)
|
|
p.output(lb + 1, dm + 30)
|
|
m.output(lb + 1, dm + 31)
|
|
|
|
b.edges.outside(c.edges).output(lb + 1, dm + 40)
|
|
b.edges.not_outside(c.edges).output(lb + 1, dm + 41)
|
|
b.edges.outside(empty.edges).output(lb + 1, dm + 42)
|
|
b.edges.not_outside(empty.edges).output(lb + 1, dm + 43)
|
|
(p, m) = b.edges.split_outside(c.edges)
|
|
p.output(lb + 1, dm + 50)
|
|
m.output(lb + 1, dm + 51)
|
|
|
|
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)
|
|
|
|
b.edges.interacting(c).output(lb + 3, dm + 20)
|
|
b.edges.not_interacting(c).output(lb + 3, dm + 21)
|
|
b.edges.interacting(empty).output(lb + 3, dm + 22)
|
|
b.edges.not_interacting(empty).output(lb + 3, dm + 23)
|
|
(p, m) = b.edges.split_interacting(c)
|
|
p.output(lb + 3, dm + 30)
|
|
m.output(lb + 3, dm + 31)
|
|
|
|
b.edges.interacting(c.edges).output(lb + 3, dm + 40)
|
|
b.edges.not_interacting(c.edges).output(lb + 3, dm + 41)
|
|
b.edges.interacting(empty.edges).output(lb + 3, dm + 42)
|
|
b.edges.not_interacting(empty.edges).output(lb + 3, dm + 43)
|
|
(p, m) = b.edges.split_interacting(c.edges)
|
|
p.output(lb + 3, dm + 50)
|
|
m.output(lb + 3, dm + 51)
|
|
|
|
bdup = b.dup
|
|
bdup.select_inside(c)
|
|
bdup.xor(b.inside(c)).output(lb + 4, dm)
|
|
bdup = b.dup
|
|
bdup.select_not_inside(c)
|
|
bdup.output(lb + 4, dm + 1)
|
|
bdup = b.dup
|
|
bdup.select_inside(empty)
|
|
bdup.output(lb + 4, dm + 2)
|
|
bdup = b.dup
|
|
bdup.select_not_inside(empty)
|
|
bdup.output(lb + 4, dm + 3)
|
|
bdup = b.dup.edges
|
|
bdup.select_inside(c)
|
|
bdup.xor(b.edges.inside(c)).output(lb + 4, dm + 10)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_inside(c)
|
|
bdup.output(lb + 4, dm + 11)
|
|
bdup = b.dup.edges
|
|
bdup.select_inside(empty)
|
|
bdup.output(lb + 4, dm + 12)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_inside(empty)
|
|
bdup.output(lb + 4, dm + 13)
|
|
bdup = b.dup.edges
|
|
bdup.select_inside(c.edges)
|
|
bdup.xor(b.edges.inside(c.edges)).output(lb + 4, dm + 20)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_inside(c.edges)
|
|
bdup.output(lb + 4, dm + 21)
|
|
bdup = b.dup.edges
|
|
bdup.select_inside(empty)
|
|
bdup.output(lb + 4, dm + 22)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_inside(empty)
|
|
bdup.output(lb + 4, dm + 23)
|
|
|
|
bdup = b.dup
|
|
bdup.select_outside(c)
|
|
bdup.xor(b.outside(c)).output(lb + 5, dm)
|
|
bdup = b.dup
|
|
bdup.select_not_outside(c)
|
|
bdup.output(lb + 5, dm + 1)
|
|
bdup = b.dup
|
|
bdup.select_outside(empty)
|
|
bdup.output(lb + 5, dm + 2)
|
|
bdup = b.dup
|
|
bdup.select_not_outside(empty)
|
|
bdup.output(lb + 5, dm + 3)
|
|
bdup = b.dup.edges
|
|
bdup.select_outside(c)
|
|
bdup.xor(b.edges.outside(c)).output(lb + 5, dm + 10)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_outside(c)
|
|
bdup.output(lb + 5, dm + 11)
|
|
bdup = b.dup.edges
|
|
bdup.select_outside(empty)
|
|
bdup.output(lb + 5, dm + 12)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_outside(empty)
|
|
bdup.output(lb + 5, dm + 13)
|
|
bdup = b.dup.edges
|
|
bdup.select_outside(c.edges)
|
|
bdup.xor(b.edges.outside(c.edges)).output(lb + 5, dm + 20)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_outside(c.edges)
|
|
bdup.output(lb + 5, dm + 21)
|
|
bdup = b.dup.edges
|
|
bdup.select_outside(empty)
|
|
bdup.output(lb + 5, dm + 22)
|
|
bdup = b.dup.edges
|
|
bdup.select_not_outside(empty)
|
|
bdup.output(lb + 5, dm + 23)
|
|
|
|
bdup = b.dup
|
|
bdup.select_overlapping(c)
|
|
bdup.xor(b.overlapping(c)).output(lb + 6, dm)
|
|
bdup = b.dup
|
|
bdup.select_not_overlapping(c)
|
|
bdup.output(lb + 6, dm + 1)
|
|
bdup = b.dup
|
|
bdup.select_overlapping(empty)
|
|
bdup.output(lb + 6, dm + 2)
|
|
bdup = b.dup
|
|
bdup.select_not_overlapping(empty)
|
|
bdup.output(lb + 6, dm + 3)
|
|
|
|
bdup = b.dup
|
|
bdup.select_interacting(c)
|
|
bdup.xor(b.interacting(c)).output(lb + 7, dm)
|
|
bdup = b.dup
|
|
bdup.select_not_interacting(c)
|
|
bdup.output(lb + 7, dm + 1)
|
|
bdup = b.dup
|
|
bdup.select_interacting(empty)
|
|
bdup.output(lb + 7, dm + 2)
|
|
bdup = b.dup
|
|
bdup.select_not_interacting(empty)
|
|
bdup.output(lb + 7, dm + 3)
|
|
|
|
b.inside(empty).output(lb + 8, dm)
|
|
b.not_inside(empty).output(lb + 8, dm + 1)
|
|
|
|
b.outside(empty).output(lb + 9, dm)
|
|
b.not_outside(empty).output(lb + 9, dm + 1)
|
|
|
|
lb += 10 #180
|
|
message "--- merge #{lb}"
|
|
|
|
if !hier
|
|
c.raw
|
|
end
|
|
if !tiled
|
|
expect_eq(c.merged.is_merged?, true)
|
|
end
|
|
c.merged.output(lb, dm)
|
|
c.merged(2).output(lb + 1, dm)
|
|
c.merged(3).output(lb + 2, dm)
|
|
if !hier
|
|
c.clean
|
|
end
|
|
cdup = c.dup
|
|
cdup.merge.xor(c.merged).output(lb + 3, dm)
|
|
cdup.xor(c.merged).output(lb + 4, dm)
|
|
cdup = c.dup
|
|
cdup.merge(2).xor(c.merged(2)).output(lb + 5, dm)
|
|
cdup.xor(c.merged(2)).output(lb + 6, dm)
|
|
|
|
lb += 10 #190
|
|
message "--- move, transform, rotate, scale #{lb}"
|
|
|
|
c.moved(0.2, -0.1).output(lb, dm)
|
|
cdup = c.dup
|
|
cdup.move(0.2, -0.1)
|
|
cdup.xor(c.moved(0.2, -0.1)).is_empty? == true || raise("xor not empty")
|
|
t = RBA::DCplxTrans::new(0.5)
|
|
c.transformed(t).output(lb + 1, dm)
|
|
cdup = c.dup
|
|
cdup.transform(t)
|
|
cdup.xor(c.transformed(t)).is_empty? == true || raise("xor not empty")
|
|
c.scaled(0.5).output(lb + 2, dm)
|
|
cdup = c.dup
|
|
cdup.scale(0.5)
|
|
cdup.xor(c.scaled(0.5)).is_empty? == true || raise("xor not empty")
|
|
c.rotated(45).output(lb + 3, dm)
|
|
cdup = c.dup
|
|
cdup.rotate(45)
|
|
cdup.xor(c.rotated(45)).is_empty? == true || raise("xor not empty")
|
|
|
|
lb += 10 #200
|
|
message "--- rectangles, rectilinear #{lb}"
|
|
|
|
a.rectangles.output(lb, dm)
|
|
a.non_rectangles.output(lb + 1, dm)
|
|
a.rectilinear.output(lb + 2, dm)
|
|
a.non_rectilinear.output(lb + 3, dm)
|
|
if !hier
|
|
c.raw
|
|
c.non_rectangles.output(lb + 4, dm)
|
|
c.clean
|
|
end
|
|
c.rectangles.output(lb + 5, dm)
|
|
|
|
lb += 10 #210
|
|
message "--- enclosing #{lb}"
|
|
|
|
a.enclosing(b, 0.5).polygons.output(lb, dm)
|
|
a.enclosing(b, 0.5).polygons.xor(a.enc(b, 0.5).polygons).is_empty? == true || raise("xor not empty")
|
|
a.enclosing(b, 0.5, euclidian).polygons.output(lb + 1, dm)
|
|
a.enclosing(b, 0.5, square).polygons.output(lb + 2, dm)
|
|
a.enclosing(b, 0.5, projection).polygons.output(lb + 3, dm)
|
|
a.enclosing(b, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
a.enclosing(b, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
a.enclosing(b, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
a.enclosing(b, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
a.enclosing(b, 0.5, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
b.enclosed(a, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 8, dm)
|
|
|
|
lb += 10 #220
|
|
message "--- enclosing (edges) #{lb}"
|
|
|
|
ae = a.edges
|
|
be = b.edges
|
|
ae.enclosing(be, 0.5).polygons.output(lb, dm)
|
|
ae.enclosing(be, 0.5).polygons.xor(ae.enc(be, 0.5).polygons).is_empty? == true || raise("xor not empty")
|
|
ae.enclosing(be, 0.5, euclidian).polygons.output(lb + 1, dm)
|
|
ae.enclosing(be, 0.5, square).polygons.output(lb + 2, dm)
|
|
ae.enclosing(be, 0.5, projection).polygons.output(lb + 3, dm)
|
|
ae.enclosing(be, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
ae.enclosing(be, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
ae.enclosing(be, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
ae.enclosing(be, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
ae.enclosing(be, 0.5, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
be.enclosed(ae, 0.5, euclidian, whole_edges).polygons.output(lb + 8, dm)
|
|
|
|
lb += 10 #230
|
|
message "--- isolated #{lb}"
|
|
|
|
b.isolated(0.4, shielded).polygons.output(lb, dm)
|
|
b.isolated(0.4, shielded).polygons.xor(b.iso(0.4, shielded).polygons).is_empty? == true || raise("xor not empty")
|
|
b.isolated(0.4, shielded, euclidian).polygons.output(lb + 1, dm)
|
|
b.isolated(0.4, shielded, square).polygons.output(lb + 2, dm)
|
|
b.isolated(0.4, shielded, projection).polygons.output(lb + 3, dm)
|
|
b.isolated(0.4, shielded, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
b.isolated(0.4, shielded, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
b.isolated(0.4, shielded, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
b.isolated(0.4, shielded, euclidian, projecting < 0.4).polygons.output(lb + 7, dm)
|
|
b.isolated(0.4, transparent).polygons.output(lb + 8, dm)
|
|
|
|
lb += 10 #240
|
|
message "--- notch #{lb}"
|
|
|
|
b.notch(0.4).polygons.output(lb, dm)
|
|
b.notch(0.4, euclidian).polygons.output(lb + 1, dm)
|
|
b.notch(0.4, square).polygons.output(lb + 2, dm)
|
|
b.notch(0.4, projection).polygons.output(lb + 3, dm)
|
|
b.notch(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
b.notch(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
b.notch(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
b.notch(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
b.notch(0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #250
|
|
message "--- overlap #{lb}"
|
|
|
|
a.overlap(b, 0.5).polygons.output(lb, dm)
|
|
a.overlap(b, 0.5, euclidian).polygons.output(lb + 1, dm)
|
|
a.overlap(b, 0.5, square).polygons.output(lb + 2, dm)
|
|
a.overlap(b, 0.5, projection).polygons.output(lb + 3, dm)
|
|
a.overlap(b, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
a.overlap(b, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
a.overlap(b, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
a.overlap(b, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
a.overlap(b, 0.5, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #260
|
|
message "--- overlap (edges) #{lb}"
|
|
|
|
ae = a.edges
|
|
be = b.edges
|
|
ae.overlap(be, 0.5).polygons.output(lb, dm)
|
|
ae.overlap(be, 0.5, euclidian).polygons.output(lb + 1, dm)
|
|
ae.overlap(be, 0.5, square).polygons.output(lb + 2, dm)
|
|
ae.overlap(be, 0.5, projection).polygons.output(lb + 3, dm)
|
|
ae.overlap(be, 0.5, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
ae.overlap(be, 0.5, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
ae.overlap(be, 0.5, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
ae.overlap(be, 0.5, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
ae.overlap(be, 0.5, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #270
|
|
message "--- separation #{lb}"
|
|
|
|
a.separation(b, 0.4).polygons.output(lb, dm)
|
|
a.separation(b, 0.4).polygons.xor(a.sep(b, 0.4).polygons).is_empty? == true || raise("xor not empty")
|
|
a.separation(b, 0.4, euclidian).polygons.output(lb + 1, dm)
|
|
a.separation(b, 0.4, square).polygons.output(lb + 2, dm)
|
|
a.separation(b, 0.4, projection).polygons.output(lb + 3, dm)
|
|
a.separation(b, 0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
a.separation(b, 0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
a.separation(b, 0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
a.separation(b, 0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
a.separation(b, 0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #280
|
|
message "--- sized #{lb}"
|
|
|
|
x.sized(0.1).output(lb, dm)
|
|
x.sized(0.1, 0).output(lb + 1, dm)
|
|
x.sized(0.1, diamond_limit).output(lb + 2, dm)
|
|
x.sized(0.1, octagon_limit).output(lb + 3, dm)
|
|
x.sized(0.1, square_limit).output(lb + 4, dm)
|
|
x.sized(0.1, acute_limit).output(lb + 5, dm)
|
|
x.sized(0.1, no_limit).output(lb + 6, dm)
|
|
xdup = x.dup
|
|
xdup.size(0.1, 0)
|
|
xdup.xor(x.sized(0.1, 0)).is_empty? == true || raise("xor not empty")
|
|
a.sized(4.0, no_limit).output(lb + 7, dm)
|
|
|
|
lb += 10 #290
|
|
message "--- space #{lb}"
|
|
|
|
b.space(0.4).polygons.output(lb, dm)
|
|
b.space(0.4, euclidian).polygons.output(lb + 1, dm)
|
|
b.space(0.4, square).polygons.output(lb + 2, dm)
|
|
b.space(0.4, projection).polygons.output(lb + 3, dm)
|
|
b.space(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
b.space(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
b.space(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
b.space(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
b.space(0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #300
|
|
message "--- space (edges) #{lb}"
|
|
|
|
be = b.edges
|
|
be.space(0.4).polygons.output(lb, dm)
|
|
be.space(0.4, euclidian).polygons.output(lb + 1, dm)
|
|
be.space(0.4, square).polygons.output(lb + 2, dm)
|
|
be.space(0.4, projection).polygons.output(lb + 3, dm)
|
|
be.space(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
be.space(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
be.space(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
be.space(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
be.space(0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #310
|
|
message "--- width #{lb}"
|
|
|
|
b.width(0.4).polygons.output(lb, dm)
|
|
b.width(0.4, euclidian).polygons.output(lb + 1, dm)
|
|
b.width(0.4, square).polygons.output(lb + 2, dm)
|
|
b.width(0.4, projection).polygons.output(lb + 3, dm)
|
|
b.width(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
b.width(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
b.width(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
b.width(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
b.width(0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #320
|
|
message "--- width (edges) #{lb}"
|
|
|
|
be = b.edges
|
|
be.width(0.4).polygons.output(lb, dm)
|
|
be.width(0.4, euclidian).polygons.output(lb + 1, dm)
|
|
be.width(0.4, square).polygons.output(lb + 2, dm)
|
|
be.width(0.4, projection).polygons.output(lb + 3, dm)
|
|
be.width(0.4, euclidian, whole_edges).polygons.output(lb + 4, dm)
|
|
be.width(0.4, euclidian, projection_limits(0.4, nil)).polygons.output(lb + 5, dm)
|
|
be.width(0.4, euclidian, projection_limits(nil, 0.4)).polygons.output(lb + 6, dm)
|
|
if has_float_range
|
|
be.width(0.4, euclidian, projection_limits(0..0.4)).polygons.output(lb + 7, dm)
|
|
else
|
|
be.width(0.4, euclidian, projection_limits(0, 0.4)).polygons.output(lb + 7, dm)
|
|
end
|
|
|
|
lb += 10 #330
|
|
message "--- with_angle #{lb}"
|
|
|
|
a.edges.with_angle(90.degree).extended_out(0.01).output(lb, dm)
|
|
a.edges.with_angle(45 .. 90.1).extended_out(0.01).output(lb + 1, dm)
|
|
a.edges.with_angle(0, 45.1).extended_out(0.01).output(lb + 2, dm)
|
|
a.edges.without_angle(90.degree).extended_out(0.01).output(lb + 3, dm)
|
|
a.edges.without_angle(45 .. 90.1).extended_out(0.01).output(lb + 4, dm)
|
|
a.edges.without_angle(0, 45.1).extended_out(0.01).output(lb + 5, dm)
|
|
a.with_angle(135).polygons.output(lb + 6, dm)
|
|
|
|
lb += 10 #340
|
|
message "--- with_area #{lb}"
|
|
|
|
b.with_area(0.49.um2).output(lb, dm)
|
|
b.with_area(0 .. 0.5).output(lb + 1, dm)
|
|
b.with_area(0.5, nil).output(lb + 2, dm)
|
|
b.without_area(0.49.um2).output(lb + 3, dm)
|
|
b.without_area(nil, 0.5).output(lb + 4, dm)
|
|
b.without_area(0.5, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #350
|
|
message "--- with_perimeter #{lb}"
|
|
|
|
b.with_perimeter(2.8.um).output(lb, dm)
|
|
b.with_perimeter(0 .. 3.um).output(lb + 1, dm)
|
|
b.with_perimeter(3.um, nil).output(lb + 2, dm)
|
|
b.without_perimeter(2.8.um).output(lb + 3, dm)
|
|
b.without_perimeter(nil, 3.um).output(lb + 4, dm)
|
|
b.without_perimeter(3.um, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #360
|
|
message "--- with_bbox_height #{lb}"
|
|
|
|
b.with_bbox_height(0.7.um).output(lb, dm)
|
|
b.with_bbox_height(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
|
|
b.with_bbox_height(0.7.um, nil).output(lb + 2, dm)
|
|
b.without_bbox_height(0.7.um).output(lb + 3, dm)
|
|
b.without_bbox_height(nil, 0.7.um+1.dbu).output(lb + 4, dm)
|
|
b.without_bbox_height(0.7.um, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #370
|
|
message "--- with_bbox_width #{lb}"
|
|
|
|
b.with_bbox_width(0.7.um).output(lb, dm)
|
|
b.with_bbox_width(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
|
|
b.with_bbox_width(0.7.um, nil).output(lb + 2, dm)
|
|
b.without_bbox_width(0.7.um).output(lb + 3, dm)
|
|
b.without_bbox_width(nil, 0.7.um+1.dbu).output(lb + 4, dm)
|
|
b.without_bbox_width(0.7.um, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #380
|
|
message "--- with_bbox_min #{lb}"
|
|
|
|
b.with_bbox_min(0.7.um).output(lb, dm)
|
|
b.with_bbox_min(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
|
|
b.with_bbox_min(0.7.um, nil).output(lb + 2, dm)
|
|
b.without_bbox_min(0.7.um).output(lb + 3, dm)
|
|
b.without_bbox_min(nil, 0.7.um+1.dbu).output(lb + 4, dm)
|
|
b.without_bbox_min(0.7.um, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #390
|
|
message "--- with_bbox_max #{lb}"
|
|
|
|
b.with_bbox_max(0.7.um).output(lb, dm)
|
|
b.with_bbox_max(0 .. 0.7.um+1.dbu).output(lb + 1, dm)
|
|
b.with_bbox_max(0.7.um, nil).output(lb + 2, dm)
|
|
b.without_bbox_max(0.7.um).output(lb + 3, dm)
|
|
b.without_bbox_max(nil, 0.7.um+1.dbu).output(lb + 4, dm)
|
|
b.without_bbox_max(0.7.um, nil).output(lb + 5, dm)
|
|
|
|
lb += 10 #400
|
|
message "--- with_length #{lb}"
|
|
|
|
a.edges.with_length(0.6.um).extended_out(0.01).output(lb, dm)
|
|
a.edges.with_length(0 .. 0.6.um+1.dbu).extended_out(0.01).output(lb + 1, dm)
|
|
a.edges.with_length(0.6, nil).extended_out(0.01).output(lb + 2, dm)
|
|
a.edges.without_length(0.6.um).extended_out(0.01).output(lb + 3, dm)
|
|
a.edges.without_length(0 .. 0.6.um+1.dbu).extended_out(0.01).output(lb + 4, dm)
|
|
a.edges.without_length(0.6, nil).extended_out(0.01).output(lb + 5, dm)
|
|
|
|
lb += 10 #410
|
|
message "--- ongrid, snap #{lb}"
|
|
|
|
a.ongrid(0.2).polygons(1.dbu).output(lb, dm)
|
|
a.ongrid(0, 0.1).polygons(1.dbu).output(lb + 1, dm)
|
|
a.snapped(0.2).output(lb + 2, dm)
|
|
a.snapped(0, 0.1).output(lb + 3, dm)
|
|
adup = a.dup
|
|
adup.snap(0.2)
|
|
adup.xor(a.snapped(0.2)).output(lb + 4, dm)
|
|
|
|
lb += 10 #420
|
|
message "--- odd polygon check #{lb}"
|
|
|
|
y.odd_polygons.output(lb, dm)
|
|
|
|
lb += 10 #430
|
|
message "--- pull_inside, pull_overlapping, pull_interacting #{lb}"
|
|
|
|
p = c.pull_inside(b)
|
|
p.output(lb, dm)
|
|
p = c.pull_interacting(b)
|
|
p.output(lb + 1, dm)
|
|
p = c.pull_overlapping(b)
|
|
p.output(lb + 2, dm)
|
|
p = c.pull_interacting(b.edges)
|
|
p.output(lb + 3, dm)
|
|
p = c.edges.pull_interacting(b)
|
|
p.output(lb + 4, dm)
|
|
p = c.edges.pull_interacting(b.edges)
|
|
p.output(lb + 5, dm)
|
|
|
|
lb += 10 #440
|
|
message "--- edge booleans, intersections #{lb}"
|
|
|
|
p = c.edges - b.edges
|
|
p.output(lb, dm)
|
|
p = b.edges - c.edges
|
|
p.output(lb + 1, dm)
|
|
p = c.edges & b.edges
|
|
p.output(lb + 2, dm)
|
|
p = c.edges ^ b.edges
|
|
p.output(lb + 3, dm)
|
|
p = c.edges.intersections(b.edges)
|
|
p.output(lb + 4, dm)
|
|
p = b.edges.intersections(c.edges)
|
|
p.output(lb + 5, dm)
|
|
(u, v) = c.edges.andnot(b.edges)
|
|
u.output(lb + 6, dm)
|
|
v.output(lb + 6, dm + 1)
|
|
p = b.edges.inside_part(c)
|
|
p.output(lb + 7, dm)
|
|
p = b.edges.outside_part(c)
|
|
p.output(lb + 7, dm + 1)
|
|
(u, v) = b.edges.inside_outside_part(c)
|
|
u.output(lb + 7, dm + 2)
|
|
v.output(lb + 7, dm + 3)
|
|
|
|
lb += 10 #450
|
|
message "--- texts and filters #{lb}"
|
|
|
|
p = at
|
|
p.output(lb, dm)
|
|
p = at.texts
|
|
p.output(lb + 1, dm)
|
|
p = at.texts("A*")
|
|
p.output(lb + 2, dm)
|
|
p = at.texts(pattern("A*"))
|
|
p.output(lb + 3, dm)
|
|
p = at.texts(pattern("A*"), as_dots)
|
|
p.output(lb + 4, dm)
|
|
p = at.texts(text("A*"), as_boxes)
|
|
p.output(lb + 5, dm)
|
|
p = at.texts_not("A*")
|
|
p.output(lb + 6, dm)
|
|
p = at.texts_not(pattern("A*"))
|
|
p.output(lb + 7, dm)
|
|
p = at.texts_not(pattern("A*"), as_dots)
|
|
p.output(lb + 8, dm)
|
|
p = at.texts_not(text("A*"), as_boxes)
|
|
p.output(lb + 9, dm)
|
|
|
|
lb += 10 #460
|
|
message "--- texts and polygon booleans and interactions #{lb}"
|
|
|
|
p = at & d
|
|
p.output(lb, dm)
|
|
p = d.interacting(at)
|
|
p.output(lb + 1, dm)
|
|
ddup = d.dup
|
|
ddup.select_interacting(at)
|
|
ddup.output(lb + 1, dm + 1)
|
|
p = at.interacting(d)
|
|
p.output(lb + 2, dm)
|
|
atdup = at.dup
|
|
atdup.select_interacting(d)
|
|
atdup.output(lb + 2, dm + 1)
|
|
p = d.pull_interacting(at)
|
|
p.output(lb + 3, dm)
|
|
p = at.pull_interacting(d)
|
|
p.output(lb + 4, dm)
|
|
p = at - d
|
|
p.output(lb + 5, dm)
|
|
p = d.not_interacting(at)
|
|
p.output(lb + 6, dm)
|
|
ddup = d.dup
|
|
ddup.select_not_interacting(at)
|
|
ddup.output(lb + 6, dm + 1)
|
|
p = at.not_interacting(d)
|
|
p.output(lb + 7, dm)
|
|
atdup = at.dup
|
|
atdup.select_not_interacting(d)
|
|
atdup.output(lb + 7, dm + 1)
|
|
p = d.interacting(at)
|
|
p.output(lb + 8, dm)
|
|
p = d.not_interacting(at)
|
|
p.output(lb + 8, dm + 1)
|
|
p = d.pull_interacting(at)
|
|
p.output(lb + 9, dm)
|
|
p = at.pull_interacting(d)
|
|
p.output(lb + 9, dm + 1)
|
|
|
|
end
|
|
|
|
if $drc_test_mode == 1
|
|
|
|
source($drc_test_source, "TOP")
|
|
target($drc_test_target, "TOP")
|
|
|
|
flat
|
|
|
|
run_testsuite(0, 1)
|
|
|
|
elsif $drc_test_mode == 2
|
|
|
|
target($drc_test_target, "TOPTOP")
|
|
source($drc_test_source, "TOPTOP")
|
|
|
|
flat
|
|
|
|
run_testsuite(0, 900)
|
|
|
|
elsif $drc_test_mode == 3
|
|
|
|
target($drc_test_target, "TOPTOP")
|
|
source($drc_test_source, "TOPTOP")
|
|
|
|
tiles(4.1, 5.2)
|
|
# must be that big ...
|
|
tile_borders(1.um, 1.um)
|
|
threads(4)
|
|
|
|
run_testsuite(0, 900, true)
|
|
|
|
elsif $drc_test_mode == 4
|
|
|
|
target($drc_test_target, "TOPTOP")
|
|
source($drc_test_source, "TOPTOP")
|
|
|
|
tiles(10000.0, 10000.0)
|
|
tile_borders(0, 0)
|
|
threads(4)
|
|
|
|
run_testsuite(0, 900, true)
|
|
|
|
elsif $drc_test_mode == 5
|
|
|
|
source($drc_test_source, "TOP")
|
|
target($drc_test_target, "TOP")
|
|
|
|
deep
|
|
|
|
run_testsuite(0, 1, false, true)
|
|
|
|
elsif $drc_test_mode == 6
|
|
|
|
target($drc_test_target, "TOPTOP")
|
|
source($drc_test_source, "TOPTOP")
|
|
|
|
deep
|
|
|
|
run_testsuite(0, 900, false, true)
|
|
|
|
end
|
|
|