138 lines
4.9 KiB
Python
138 lines
4.9 KiB
Python
from pathlib import Path
|
|
from typing import cast
|
|
import pytest
|
|
from numpy.testing import assert_allclose
|
|
|
|
from ..pattern import Pattern
|
|
from ..library import Library
|
|
from ..shapes import Path as MPath, Circle, Polygon, RectCollection
|
|
from ..repetition import Grid, Arbitrary
|
|
|
|
def create_test_library(for_gds: bool = False) -> Library:
|
|
lib = Library()
|
|
|
|
pat_poly = Pattern()
|
|
pat_poly.polygon((1, 0), vertices=[[0, 0], [10, 0], [5, 10]])
|
|
lib["polygons"] = pat_poly
|
|
|
|
pat_paths = Pattern()
|
|
pat_paths.path((2, 0), vertices=[[0, 0], [20, 0]], width=2, cap=MPath.Cap.Flush)
|
|
pat_paths.path((2, 1), vertices=[[0, 10], [20, 10]], width=2, cap=MPath.Cap.Square)
|
|
if for_gds:
|
|
pat_paths.path((2, 2), vertices=[[0, 20], [20, 20]], width=2, cap=MPath.Cap.Circle)
|
|
pat_paths.path((2, 3), vertices=[[0, 30], [20, 30]], width=2, cap=MPath.Cap.SquareCustom, cap_extensions=(1, 5))
|
|
lib["paths"] = pat_paths
|
|
|
|
pat_circles = Pattern()
|
|
if for_gds:
|
|
pat_circles.shapes[(3, 0)].append(Circle(radius=5, offset=(10, 10)).to_polygons()[0])
|
|
else:
|
|
pat_circles.shapes[(3, 0)].append(Circle(radius=5, offset=(10, 10)))
|
|
lib["circles"] = pat_circles
|
|
|
|
pat_refs = Pattern()
|
|
pat_refs.ref("polygons", offset=(0, 0))
|
|
pat_refs.ref("polygons", offset=(100, 0), repetition=Grid(a_vector=(20, 0), a_count=3, b_vector=(0, 20), b_count=2))
|
|
pat_refs.ref("polygons", offset=(0, 100), repetition=Arbitrary(displacements=[[0, 0], [10, 20], [30, -10]]))
|
|
lib["refs"] = pat_refs
|
|
|
|
pat_rep_shapes = Pattern()
|
|
poly_rep = Polygon(vertices=[[0, 0], [5, 0], [5, 5], [0, 5]], repetition=Grid(a_vector=(10, 0), a_count=5))
|
|
pat_rep_shapes.shapes[(4, 0)].append(poly_rep)
|
|
lib["rep_shapes"] = pat_rep_shapes
|
|
|
|
if for_gds:
|
|
lib.wrap_repeated_shapes()
|
|
|
|
return lib
|
|
|
|
def test_gdsii_full_roundtrip(tmp_path: Path) -> None:
|
|
from ..file import gdsii
|
|
lib = create_test_library(for_gds=True)
|
|
gds_file = tmp_path / "full_test.gds"
|
|
gdsii.writefile(lib, gds_file, meters_per_unit=1e-9)
|
|
|
|
read_lib, _ = gdsii.readfile(gds_file)
|
|
|
|
for name in lib:
|
|
assert name in read_lib
|
|
|
|
read_paths = read_lib["paths"]
|
|
p_flush = cast("MPath", read_paths.shapes[(2, 0)][0])
|
|
assert p_flush.cap == MPath.Cap.Flush
|
|
|
|
p_square = cast("MPath", read_paths.shapes[(2, 1)][0])
|
|
assert p_square.cap == MPath.Cap.Square
|
|
|
|
p_circle = cast("MPath", read_paths.shapes[(2, 2)][0])
|
|
assert p_circle.cap == MPath.Cap.Circle
|
|
|
|
p_custom = cast("MPath", read_paths.shapes[(2, 3)][0])
|
|
assert p_custom.cap == MPath.Cap.SquareCustom
|
|
assert p_custom.cap_extensions is not None
|
|
assert_allclose(p_custom.cap_extensions, (1, 5))
|
|
|
|
read_refs = read_lib["refs"]
|
|
assert len(read_refs.refs["polygons"]) >= 3 # Simple, Grid (becomes 1 AREF), Arbitrary (becomes 3 SREFs)
|
|
|
|
arefs = [r for r in read_refs.refs["polygons"] if r.repetition is not None]
|
|
assert len(arefs) == 1
|
|
assert isinstance(arefs[0].repetition, Grid)
|
|
assert arefs[0].repetition.a_count == 3
|
|
assert arefs[0].repetition.b_count == 2
|
|
|
|
# GDS stores repeated shapes through refs created by wrap_repeated_shapes().
|
|
assert len(read_lib["rep_shapes"].refs) > 0
|
|
|
|
def test_oasis_full_roundtrip(tmp_path: Path) -> None:
|
|
pytest.importorskip("fatamorgana")
|
|
from ..file import oasis
|
|
lib = create_test_library(for_gds=False)
|
|
oas_file = tmp_path / "full_test.oas"
|
|
oasis.writefile(lib, oas_file, units_per_micron=1000)
|
|
|
|
read_lib, _ = oasis.readfile(oas_file)
|
|
|
|
for name in lib:
|
|
assert name in read_lib
|
|
|
|
read_circles = read_lib["circles"]
|
|
assert isinstance(read_circles.shapes[(3, 0)][0], Circle)
|
|
assert read_circles.shapes[(3, 0)][0].radius == 5
|
|
|
|
read_paths = read_lib["paths"]
|
|
assert cast("MPath", read_paths.shapes[(2, 0)][0]).cap == MPath.Cap.Flush
|
|
assert cast("MPath", read_paths.shapes[(2, 1)][0]).cap == MPath.Cap.Square
|
|
|
|
read_rep_shapes = read_lib["rep_shapes"]
|
|
poly = read_rep_shapes.shapes[(4, 0)][0]
|
|
assert poly.repetition is not None
|
|
assert isinstance(poly.repetition, Grid)
|
|
assert poly.repetition.a_count == 5
|
|
|
|
|
|
def test_gdsii_rect_collection_roundtrip(tmp_path: Path) -> None:
|
|
from ..file import gdsii
|
|
|
|
lib = Library()
|
|
pat = Pattern()
|
|
pat.shapes[(5, 0)].append(
|
|
RectCollection(
|
|
rects=[[0, 0, 10, 5], [20, -5, 30, 10]],
|
|
annotations={'1': ['rects']},
|
|
)
|
|
)
|
|
lib['rects'] = pat
|
|
|
|
gds_file = tmp_path / 'rect_collection.gds'
|
|
gdsii.writefile(lib, gds_file, meters_per_unit=1e-9)
|
|
|
|
read_lib, _ = gdsii.readfile(gds_file)
|
|
polys = read_lib['rects'].shapes[(5, 0)]
|
|
|
|
assert len(polys) == 2
|
|
assert all(isinstance(poly, Polygon) for poly in polys)
|
|
assert_allclose(polys[0].vertices, [[0, 0], [0, 5], [10, 5], [10, 0]])
|
|
assert_allclose(polys[1].vertices, [[20, -5], [20, 10], [30, 10], [30, -5]])
|
|
assert polys[0].annotations == {'1': ['rects']}
|
|
assert polys[1].annotations == {'1': ['rects']}
|