Add lib types
This commit is contained in:
parent
273d828d87
commit
9bb7ddbb79
@ -29,118 +29,18 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
visitor_function_t = Callable[['Pattern', Tuple['Pattern'], Dict, NDArray[numpy.float64]], 'Pattern']
|
||||
L = TypeVar('L', bound='Library')
|
||||
LL = TypeVar('LL', bound='LazyLibrary')
|
||||
|
||||
|
||||
class Library:
|
||||
"""
|
||||
This class is usually used to create a library of Patterns by mapping names to
|
||||
functions which generate or load the relevant `Pattern` object as-needed.
|
||||
class Library(Mapping[str, Pattern], metaclass=ABCMeta):
|
||||
#def __getitem__(self, key: str) -> 'Pattern':
|
||||
#def __iter__(self) -> Iterator[str]:
|
||||
#def __len__(self) -> int:
|
||||
|
||||
The cache can be disabled by setting the `enable_cache` attribute to `False`.
|
||||
"""
|
||||
dict: Dict[str, Callable[[], Pattern]]
|
||||
cache: Dict[str, 'Pattern']
|
||||
enable_cache: bool = True
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.dict = {}
|
||||
self.cache = {}
|
||||
|
||||
def __setitem__(self, key: str, value: Callable[[], Pattern]) -> None:
|
||||
self.dict[key] = value
|
||||
if key in self.cache:
|
||||
del self.cache[key]
|
||||
|
||||
def __delitem__(self, key: str) -> None:
|
||||
del self.dict[key]
|
||||
if key in self.cache:
|
||||
del self.cache[key]
|
||||
|
||||
def __getitem__(self, key: str) -> 'Pattern':
|
||||
logger.debug(f'loading {key}')
|
||||
if self.enable_cache and key in self.cache:
|
||||
logger.debug(f'found {key} in cache')
|
||||
return self.cache[key]
|
||||
|
||||
func = self.dict[key]
|
||||
pat = func()
|
||||
self.cache[key] = pat
|
||||
return pat
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
return iter(self.keys())
|
||||
|
||||
def __contains__(self, key: str) -> bool:
|
||||
return key in self.dict
|
||||
|
||||
def keys(self) -> Iterator[str]:
|
||||
return iter(self.dict.keys())
|
||||
|
||||
def values(self) -> Iterator['Pattern']:
|
||||
return iter(self[key] for key in self.keys())
|
||||
|
||||
def items(self) -> Iterator[Tuple[str, 'Pattern']]:
|
||||
return iter((key, self[key]) for key in self.keys())
|
||||
#__contains__, keys, items, values, get, __eq__, __ne__ supplied by Mapping
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return '<Library with keys ' + repr(list(self.dict.keys())) + '>'
|
||||
|
||||
def precache(self: L) -> L:
|
||||
"""
|
||||
Force all patterns into the cache
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
for key in self.dict:
|
||||
_ = self.dict.__getitem__(key)
|
||||
return self
|
||||
|
||||
def add(
|
||||
self: L,
|
||||
other: L,
|
||||
use_ours: Callable[[str], bool] = lambda name: False,
|
||||
use_theirs: Callable[[str], bool] = lambda name: False,
|
||||
) -> L:
|
||||
"""
|
||||
Add keys from another library into this one.
|
||||
|
||||
Args:
|
||||
other: The library to insert keys from
|
||||
use_ours: Decision function for name conflicts, called with cell name.
|
||||
Should return `True` if the value from `self` should be used.
|
||||
use_theirs: Decision function for name conflicts. Same format as `use_ours`.
|
||||
Should return `True` if the value from `other` should be used.
|
||||
`use_ours` takes priority over `use_theirs`.
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
duplicates = set(self.keys()) & set(other.keys())
|
||||
keep_ours = set(name for name in duplicates if use_ours(name))
|
||||
keep_theirs = set(name for name in duplicates - keep_ours if use_theirs(name))
|
||||
conflicts = duplicates - keep_ours - keep_theirs
|
||||
|
||||
if conflicts:
|
||||
raise LibraryError('Unresolved duplicate keys encountered in library merge: ' + pformat(conflicts))
|
||||
|
||||
for key in set(other.keys()) - keep_ours:
|
||||
self.dict[key] = other.dict[key]
|
||||
if key in other.cache:
|
||||
self.cache[key] = other.cache[key]
|
||||
|
||||
return self
|
||||
|
||||
def clear_cache(self: L) -> L:
|
||||
"""
|
||||
Clear the cache of this library.
|
||||
This is usually used before modifying or deleting cells, e.g. when merging
|
||||
with another library.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
self.cache.clear()
|
||||
return self
|
||||
return '<Library with keys ' + repr(list(self.keys())) + '>'
|
||||
|
||||
def referenced_patterns(
|
||||
self,
|
||||
@ -176,10 +76,11 @@ class Library:
|
||||
|
||||
return targets
|
||||
|
||||
# TODO maybe not for immutable?
|
||||
def subtree(
|
||||
self: L,
|
||||
tops: Union[str, Sequence[str]],
|
||||
) -> L:
|
||||
) -> ML:
|
||||
"""
|
||||
Return a new `Library`, containing only the specified patterns and the patterns they
|
||||
reference (recursively).
|
||||
@ -192,107 +93,10 @@ class Library:
|
||||
"""
|
||||
keep: Set[str] = self.referenced_patterns(tops) - set((None,)) # type: ignore
|
||||
|
||||
new = type(self)()
|
||||
for key in keep:
|
||||
new.dict[key] = self.dict[key]
|
||||
if key in self.cache:
|
||||
new.cache[key] = self.cache[key]
|
||||
|
||||
filtered = {kk: vv for kk, vv in self.items() if kk in keep}
|
||||
new = WrapLibrary(filtered)
|
||||
return new
|
||||
|
||||
def dfs(
|
||||
self: L,
|
||||
top: str,
|
||||
visit_before: visitor_function_t = None,
|
||||
visit_after: visitor_function_t = None,
|
||||
transform: Union[ArrayLike, bool, None] = False,
|
||||
memo: Optional[Dict] = None,
|
||||
hierarchy: Tuple[str, ...] = (),
|
||||
) -> L:
|
||||
"""
|
||||
Convenience function.
|
||||
Performs a depth-first traversal of a pattern and its subpatterns.
|
||||
At each pattern in the tree, the following sequence is called:
|
||||
```
|
||||
current_pattern = visit_before(current_pattern, **vist_args)
|
||||
for sp in current_pattern.subpatterns]
|
||||
self.dfs(sp.target, visit_before, visit_after, updated_transform,
|
||||
memo, (current_pattern,) + hierarchy)
|
||||
current_pattern = visit_after(current_pattern, **visit_args)
|
||||
```
|
||||
where `visit_args` are
|
||||
`hierarchy`: (top_pattern, L1_pattern, L2_pattern, ..., parent_pattern)
|
||||
tuple of all parent-and-higher patterns
|
||||
`transform`: numpy.ndarray containing cumulative
|
||||
[x_offset, y_offset, rotation (rad), mirror_x (0 or 1)]
|
||||
for the instance being visited
|
||||
`memo`: Arbitrary dict (not altered except by `visit_before()` and `visit_after()`)
|
||||
|
||||
Args:
|
||||
top: Name of the pattern to start at (root node of the tree).
|
||||
visit_before: Function to call before traversing subpatterns.
|
||||
Should accept a `Pattern` and `**visit_args`, and return the (possibly modified)
|
||||
pattern. Default `None` (not called).
|
||||
visit_after: Function to call after traversing subpatterns.
|
||||
Should accept a `Pattern` and `**visit_args`, and return the (possibly modified)
|
||||
pattern. Default `None` (not called).
|
||||
transform: Initial value for `visit_args['transform']`.
|
||||
Can be `False`, in which case the transform is not calculated.
|
||||
`True` or `None` is interpreted as `[0, 0, 0, 0]`.
|
||||
memo: Arbitrary dict for use by `visit_*()` functions. Default `None` (empty dict).
|
||||
hierarchy: Tuple of patterns specifying the hierarchy above the current pattern.
|
||||
Appended to the start of the generated `visit_args['hierarchy']`.
|
||||
Default is an empty tuple.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
if memo is None:
|
||||
memo = {}
|
||||
|
||||
if transform is None or transform is True:
|
||||
transform = numpy.zeros(4)
|
||||
elif transform is not False:
|
||||
transform = numpy.array(transform)
|
||||
|
||||
if top in hierarchy:
|
||||
raise PatternError('.dfs() called on pattern with circular reference')
|
||||
|
||||
pat = self[top]
|
||||
if visit_before is not None:
|
||||
pat = visit_before(pat, hierarchy=hierarchy, memo=memo, transform=transform) # type: ignore
|
||||
|
||||
for subpattern in pat.subpatterns:
|
||||
if transform is not False:
|
||||
sign = numpy.ones(2)
|
||||
if transform[3]:
|
||||
sign[1] = -1
|
||||
xy = numpy.dot(rotation_matrix_2d(transform[2]), subpattern.offset * sign)
|
||||
mirror_x, angle = normalize_mirror(subpattern.mirrored)
|
||||
angle += subpattern.rotation
|
||||
sp_transform = transform + (xy[0], xy[1], angle, mirror_x)
|
||||
sp_transform[3] %= 2
|
||||
else:
|
||||
sp_transform = False
|
||||
|
||||
if subpattern.target is None:
|
||||
continue
|
||||
|
||||
self.dfs(
|
||||
top=subpattern.target,
|
||||
visit_before=visit_before,
|
||||
visit_after=visit_after,
|
||||
transform=sp_transform,
|
||||
memo=memo,
|
||||
hierarchy=hierarchy + (top,),
|
||||
)
|
||||
|
||||
if visit_after is not None:
|
||||
pat = visit_after(pat, hierarchy=hierarchy, memo=memo, transform=transform) # type: ignore
|
||||
|
||||
self[top] = lambda: pat
|
||||
return self
|
||||
|
||||
def polygonize(
|
||||
self: L,
|
||||
poly_num_points: Optional[int] = None,
|
||||
@ -335,153 +139,6 @@ class Library:
|
||||
pat.manhattanize(grid_x, grid_y)
|
||||
return self
|
||||
|
||||
def subpatternize(
|
||||
self: L,
|
||||
norm_value: int = int(1e6),
|
||||
exclude_types: Tuple[Type] = (Polygon,),
|
||||
label2name: Optional[Callable[[Tuple], str]] = None,
|
||||
threshold: int = 2,
|
||||
) -> L:
|
||||
"""
|
||||
Iterates through all `Pattern`s. Within each `Pattern`, it iterates
|
||||
over all shapes, calling `.normalized_form(norm_value)` on them to retrieve a scale-,
|
||||
offset-, dose-, and rotation-independent form. Each shape whose normalized form appears
|
||||
more than once is removed and re-added using subpattern objects referencing a newly-created
|
||||
`Pattern` containing only the normalized form of the shape.
|
||||
|
||||
Note:
|
||||
The default norm_value was chosen to give a reasonable precision when using
|
||||
integer values for coordinates.
|
||||
|
||||
Args:
|
||||
norm_value: Passed to `shape.normalized_form(norm_value)`. Default `1e6` (see function
|
||||
note)
|
||||
exclude_types: Shape types passed in this argument are always left untouched, for
|
||||
speed or convenience. Default: `(shapes.Polygon,)`
|
||||
label2name: Given a label tuple as returned by `shape.normalized_form(...)`, pick
|
||||
a name for the generated pattern. Default `self.get_name('_shape')`.
|
||||
threshold: Only replace shapes with subpatterns if there will be at least this many
|
||||
instances.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
# This currently simplifies globally (same shape in different patterns is
|
||||
# merged into the same subpattern target.
|
||||
|
||||
if exclude_types is None:
|
||||
exclude_types = ()
|
||||
|
||||
if label2name is None:
|
||||
label2name = lambda label: self.get_name('_shape')
|
||||
|
||||
|
||||
shape_counts: MutableMapping[Tuple, int] = defaultdict(int)
|
||||
shape_funcs = {}
|
||||
|
||||
### First pass ###
|
||||
# Using the label tuple from `.normalized_form()` as a key, check how many of each shape
|
||||
# are present and store the shape function for each one
|
||||
for pat in tuple(self.values()):
|
||||
for i, shape in enumerate(pat.shapes):
|
||||
if not any(isinstance(shape, t) for t in exclude_types):
|
||||
label, _values, func = shape.normalized_form(norm_value)
|
||||
shape_funcs[label] = func
|
||||
shape_counts[label] += 1
|
||||
|
||||
shape_pats = {}
|
||||
for label, count in shape_counts.items():
|
||||
if count < threshold:
|
||||
continue
|
||||
|
||||
shape_func = shape_funcs[label]
|
||||
shape_pat = Pattern(shapes=[shape_func()])
|
||||
shape_pats[label] = shape_pat
|
||||
|
||||
### Second pass ###
|
||||
for pat in tuple(self.values()):
|
||||
# Store `[(index_in_shapes, values_from_normalized_form), ...]` for all shapes which
|
||||
# are to be replaced.
|
||||
# The `values` are `(offset, scale, rotation, dose)`.
|
||||
|
||||
shape_table: MutableMapping[Tuple, List] = defaultdict(list)
|
||||
for i, shape in enumerate(pat.shapes):
|
||||
if any(isinstance(shape, t) for t in exclude_types):
|
||||
continue
|
||||
|
||||
label, values, _func = shape.normalized_form(norm_value)
|
||||
|
||||
if label not in shape_pats:
|
||||
continue
|
||||
|
||||
shape_table[label].append((i, values))
|
||||
|
||||
# For repeated shapes, create a `Pattern` holding a normalized shape object,
|
||||
# and add `pat.subpatterns` entries for each occurrence in pat. Also, note down that
|
||||
# we should delete the `pat.shapes` entries for which we made SubPatterns.
|
||||
shapes_to_remove = []
|
||||
for label in shape_table:
|
||||
target = label2name(label)
|
||||
for i, values in shape_table[label]:
|
||||
offset, scale, rotation, mirror_x, dose = values
|
||||
pat.addsp(target=target, offset=offset, scale=scale,
|
||||
rotation=rotation, dose=dose, mirrored=(mirror_x, False))
|
||||
shapes_to_remove.append(i)
|
||||
|
||||
# Remove any shapes for which we have created subpatterns.
|
||||
for i in sorted(shapes_to_remove, reverse=True):
|
||||
del pat.shapes[i]
|
||||
|
||||
for ll, pp in shape_pats.items():
|
||||
self[label2name(ll)] = lambda: pp
|
||||
|
||||
return self
|
||||
|
||||
def wrap_repeated_shapes(
|
||||
self: L,
|
||||
name_func: Optional[Callable[['Pattern', Union[Shape, Label]], str]] = None,
|
||||
) -> L:
|
||||
"""
|
||||
Wraps all shapes and labels with a non-`None` `repetition` attribute
|
||||
into a `SubPattern`/`Pattern` combination, and applies the `repetition`
|
||||
to each `SubPattern` instead of its contained shape.
|
||||
|
||||
Args:
|
||||
name_func: Function f(this_pattern, shape) which generates a name for the
|
||||
wrapping pattern. Default is `self.get_name('_rep')`.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
if name_func is None:
|
||||
name_func = lambda _pat, _shape: self.get_name('_rep')
|
||||
|
||||
for pat in tuple(self.values()):
|
||||
new_shapes = []
|
||||
for shape in pat.shapes:
|
||||
if shape.repetition is None:
|
||||
new_shapes.append(shape)
|
||||
continue
|
||||
|
||||
name = name_func(pat, shape)
|
||||
self[name] = lambda: Pattern(shapes=[shape])
|
||||
pat.addsp(name, repetition=shape.repetition)
|
||||
shape.repetition = None
|
||||
pat.shapes = new_shapes
|
||||
|
||||
new_labels = []
|
||||
for label in pat.labels:
|
||||
if label.repetition is None:
|
||||
new_labels.append(label)
|
||||
continue
|
||||
name = name_func(pat, label)
|
||||
self[name] = lambda: Pattern(labels=[label])
|
||||
pat.addsp(name, repetition=label.repetition)
|
||||
label.repetition = None
|
||||
pat.labels = new_labels
|
||||
|
||||
return self
|
||||
|
||||
def flatten(
|
||||
self: L,
|
||||
tops: Union[str, Sequence[str]],
|
||||
@ -590,5 +247,457 @@ class Library:
|
||||
toplevel = list(names - not_toplevel)
|
||||
return toplevel
|
||||
|
||||
def __deepcopy__(self, memo: Dict = None) -> 'Library':
|
||||
raise LibraryError('Libraries cannot be deepcopied (deepcopy doesn\'t descend into closures)')
|
||||
|
||||
class MutableLibrary(Library, metaclass=ABCMeta):
|
||||
@abstractmethod
|
||||
def __setitem__(self, key: str, value: VVV) -> None:
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def __delitem__(self, key: str) -> None:
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def __delitem__(self, key: str) -> None:
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def _set(self, key: str, value: Pattern) -> None:
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def _copy(self: ML, other: ML, key: str) -> None:
|
||||
pass
|
||||
|
||||
def add(
|
||||
self: WL,
|
||||
other: L,
|
||||
use_ours: Callable[[str], bool] = lambda name: False,
|
||||
use_theirs: Callable[[str], bool] = lambda name: False,
|
||||
) -> ML:
|
||||
"""
|
||||
Add keys from another library into this one.
|
||||
|
||||
Args:
|
||||
other: The library to insert keys from
|
||||
use_ours: Decision function for name conflicts, called with cell name.
|
||||
Should return `True` if the value from `self` should be used.
|
||||
use_theirs: Decision function for name conflicts. Same format as `use_ours`.
|
||||
Should return `True` if the value from `other` should be used.
|
||||
`use_ours` takes priority over `use_theirs`.
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
duplicates = set(self.keys()) & set(other.keys())
|
||||
keep_ours = set(name for name in duplicates if use_ours(name))
|
||||
keep_theirs = set(name for name in duplicates - keep_ours if use_theirs(name))
|
||||
conflicts = duplicates - keep_ours - keep_theirs
|
||||
|
||||
if conflicts:
|
||||
raise LibraryError('Unresolved duplicate keys encountered in library merge: ' + pformat(conflicts))
|
||||
|
||||
for key in set(other.keys()) - keep_ours:
|
||||
self._merge(other, key)
|
||||
|
||||
return self
|
||||
|
||||
#TODO maybe also in immutable case?
|
||||
def dfs(
|
||||
self: ML,
|
||||
top: str,
|
||||
visit_before: visitor_function_t = None,
|
||||
visit_after: visitor_function_t = None,
|
||||
transform: Union[ArrayLike, bool, None] = False,
|
||||
memo: Optional[Dict] = None,
|
||||
hierarchy: Tuple[str, ...] = (),
|
||||
) -> ML:
|
||||
"""
|
||||
Convenience function.
|
||||
Performs a depth-first traversal of a pattern and its subpatterns.
|
||||
At each pattern in the tree, the following sequence is called:
|
||||
```
|
||||
current_pattern = visit_before(current_pattern, **vist_args)
|
||||
for sp in current_pattern.subpatterns]
|
||||
self.dfs(sp.target, visit_before, visit_after, updated_transform,
|
||||
memo, (current_pattern,) + hierarchy)
|
||||
current_pattern = visit_after(current_pattern, **visit_args)
|
||||
```
|
||||
where `visit_args` are
|
||||
`hierarchy`: (top_pattern, L1_pattern, L2_pattern, ..., parent_pattern)
|
||||
tuple of all parent-and-higher patterns
|
||||
`transform`: numpy.ndarray containing cumulative
|
||||
[x_offset, y_offset, rotation (rad), mirror_x (0 or 1)]
|
||||
for the instance being visited
|
||||
`memo`: Arbitrary dict (not altered except by `visit_before()` and `visit_after()`)
|
||||
|
||||
Args:
|
||||
top: Name of the pattern to start at (root node of the tree).
|
||||
visit_before: Function to call before traversing subpatterns.
|
||||
Should accept a `Pattern` and `**visit_args`, and return the (possibly modified)
|
||||
pattern. Default `None` (not called).
|
||||
visit_after: Function to call after traversing subpatterns.
|
||||
Should accept a `Pattern` and `**visit_args`, and return the (possibly modified)
|
||||
pattern. Default `None` (not called).
|
||||
transform: Initial value for `visit_args['transform']`.
|
||||
Can be `False`, in which case the transform is not calculated.
|
||||
`True` or `None` is interpreted as `[0, 0, 0, 0]`.
|
||||
memo: Arbitrary dict for use by `visit_*()` functions. Default `None` (empty dict).
|
||||
hierarchy: Tuple of patterns specifying the hierarchy above the current pattern.
|
||||
Appended to the start of the generated `visit_args['hierarchy']`.
|
||||
Default is an empty tuple.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
if memo is None:
|
||||
memo = {}
|
||||
|
||||
if transform is None or transform is True:
|
||||
transform = numpy.zeros(4)
|
||||
elif transform is not False:
|
||||
transform = numpy.array(transform)
|
||||
|
||||
if top in hierarchy:
|
||||
raise PatternError('.dfs() called on pattern with circular reference')
|
||||
|
||||
pat = self[top]
|
||||
if visit_before is not None:
|
||||
pat = visit_before(pat, hierarchy=hierarchy, memo=memo, transform=transform) # type: ignore
|
||||
|
||||
for subpattern in pat.subpatterns:
|
||||
if transform is not False:
|
||||
sign = numpy.ones(2)
|
||||
if transform[3]:
|
||||
sign[1] = -1
|
||||
xy = numpy.dot(rotation_matrix_2d(transform[2]), subpattern.offset * sign)
|
||||
mirror_x, angle = normalize_mirror(subpattern.mirrored)
|
||||
angle += subpattern.rotation
|
||||
sp_transform = transform + (xy[0], xy[1], angle, mirror_x)
|
||||
sp_transform[3] %= 2
|
||||
else:
|
||||
sp_transform = False
|
||||
|
||||
if subpattern.target is None:
|
||||
continue
|
||||
|
||||
self.dfs(
|
||||
top=subpattern.target,
|
||||
visit_before=visit_before,
|
||||
visit_after=visit_after,
|
||||
transform=sp_transform,
|
||||
memo=memo,
|
||||
hierarchy=hierarchy + (top,),
|
||||
)
|
||||
|
||||
if visit_after is not None:
|
||||
pat = visit_after(pat, hierarchy=hierarchy, memo=memo, transform=transform) # type: ignore
|
||||
|
||||
self._set(top, pat)
|
||||
return self
|
||||
|
||||
def subpatternize(
|
||||
self: ML,
|
||||
norm_value: int = int(1e6),
|
||||
exclude_types: Tuple[Type] = (Polygon,),
|
||||
label2name: Optional[Callable[[Tuple], str]] = None,
|
||||
threshold: int = 2,
|
||||
) -> ML:
|
||||
"""
|
||||
Iterates through all `Pattern`s. Within each `Pattern`, it iterates
|
||||
over all shapes, calling `.normalized_form(norm_value)` on them to retrieve a scale-,
|
||||
offset-, dose-, and rotation-independent form. Each shape whose normalized form appears
|
||||
more than once is removed and re-added using subpattern objects referencing a newly-created
|
||||
`Pattern` containing only the normalized form of the shape.
|
||||
|
||||
Note:
|
||||
The default norm_value was chosen to give a reasonable precision when using
|
||||
integer values for coordinates.
|
||||
|
||||
Args:
|
||||
norm_value: Passed to `shape.normalized_form(norm_value)`. Default `1e6` (see function
|
||||
note)
|
||||
exclude_types: Shape types passed in this argument are always left untouched, for
|
||||
speed or convenience. Default: `(shapes.Polygon,)`
|
||||
label2name: Given a label tuple as returned by `shape.normalized_form(...)`, pick
|
||||
a name for the generated pattern. Default `self.get_name('_shape')`.
|
||||
threshold: Only replace shapes with subpatterns if there will be at least this many
|
||||
instances.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
# This currently simplifies globally (same shape in different patterns is
|
||||
# merged into the same subpattern target.
|
||||
|
||||
if exclude_types is None:
|
||||
exclude_types = ()
|
||||
|
||||
if label2name is None:
|
||||
label2name = lambda label: self.get_name('_shape')
|
||||
|
||||
|
||||
shape_counts: MutableMapping[Tuple, int] = defaultdict(int)
|
||||
shape_funcs = {}
|
||||
|
||||
### First pass ###
|
||||
# Using the label tuple from `.normalized_form()` as a key, check how many of each shape
|
||||
# are present and store the shape function for each one
|
||||
for pat in tuple(self.values()):
|
||||
for i, shape in enumerate(pat.shapes):
|
||||
if not any(isinstance(shape, t) for t in exclude_types):
|
||||
label, _values, func = shape.normalized_form(norm_value)
|
||||
shape_funcs[label] = func
|
||||
shape_counts[label] += 1
|
||||
|
||||
shape_pats = {}
|
||||
for label, count in shape_counts.items():
|
||||
if count < threshold:
|
||||
continue
|
||||
|
||||
shape_func = shape_funcs[label]
|
||||
shape_pat = Pattern(shapes=[shape_func()])
|
||||
shape_pats[label] = shape_pat
|
||||
|
||||
### Second pass ###
|
||||
for pat in tuple(self.values()):
|
||||
# Store `[(index_in_shapes, values_from_normalized_form), ...]` for all shapes which
|
||||
# are to be replaced.
|
||||
# The `values` are `(offset, scale, rotation, dose)`.
|
||||
|
||||
shape_table: MutableMapping[Tuple, List] = defaultdict(list)
|
||||
for i, shape in enumerate(pat.shapes):
|
||||
if any(isinstance(shape, t) for t in exclude_types):
|
||||
continue
|
||||
|
||||
label, values, _func = shape.normalized_form(norm_value)
|
||||
|
||||
if label not in shape_pats:
|
||||
continue
|
||||
|
||||
shape_table[label].append((i, values))
|
||||
|
||||
# For repeated shapes, create a `Pattern` holding a normalized shape object,
|
||||
# and add `pat.subpatterns` entries for each occurrence in pat. Also, note down that
|
||||
# we should delete the `pat.shapes` entries for which we made SubPatterns.
|
||||
shapes_to_remove = []
|
||||
for label in shape_table:
|
||||
target = label2name(label)
|
||||
for i, values in shape_table[label]:
|
||||
offset, scale, rotation, mirror_x, dose = values
|
||||
pat.addsp(target=target, offset=offset, scale=scale,
|
||||
rotation=rotation, dose=dose, mirrored=(mirror_x, False))
|
||||
shapes_to_remove.append(i)
|
||||
|
||||
# Remove any shapes for which we have created subpatterns.
|
||||
for i in sorted(shapes_to_remove, reverse=True):
|
||||
del pat.shapes[i]
|
||||
|
||||
for ll, pp in shape_pats.items():
|
||||
self._set(label2name(ll), pp)
|
||||
|
||||
return self
|
||||
|
||||
def wrap_repeated_shapes(
|
||||
self: ML,
|
||||
name_func: Optional[Callable[['Pattern', Union[Shape, Label]], str]] = None,
|
||||
) -> ML:
|
||||
"""
|
||||
Wraps all shapes and labels with a non-`None` `repetition` attribute
|
||||
into a `SubPattern`/`Pattern` combination, and applies the `repetition`
|
||||
to each `SubPattern` instead of its contained shape.
|
||||
|
||||
Args:
|
||||
name_func: Function f(this_pattern, shape) which generates a name for the
|
||||
wrapping pattern. Default is `self.get_name('_rep')`.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
if name_func is None:
|
||||
name_func = lambda _pat, _shape: self.get_name('_rep')
|
||||
|
||||
for pat in tuple(self.values()):
|
||||
new_shapes = []
|
||||
for shape in pat.shapes:
|
||||
if shape.repetition is None:
|
||||
new_shapes.append(shape)
|
||||
continue
|
||||
|
||||
name = name_func(pat, shape)
|
||||
self._set(name, Pattern(shapes=[shape]))
|
||||
pat.addsp(name, repetition=shape.repetition)
|
||||
shape.repetition = None
|
||||
pat.shapes = new_shapes
|
||||
|
||||
new_labels = []
|
||||
for label in pat.labels:
|
||||
if label.repetition is None:
|
||||
new_labels.append(label)
|
||||
continue
|
||||
name = name_func(pat, label)
|
||||
self._set(name, Pattern(labels=[label]))
|
||||
pat.addsp(name, repetition=label.repetition)
|
||||
label.repetition = None
|
||||
pat.labels = new_labels
|
||||
|
||||
return self
|
||||
|
||||
def subtree(
|
||||
self: ML,
|
||||
tops: Union[str, Sequence[str]],
|
||||
) -> ML:
|
||||
"""
|
||||
Return a new `Library`, containing only the specified patterns and the patterns they
|
||||
reference (recursively).
|
||||
|
||||
Args:
|
||||
tops: Name(s) of patterns to keep
|
||||
|
||||
Returns:
|
||||
A `Library` containing only `tops` and the patterns they reference.
|
||||
"""
|
||||
keep: Set[str] = self.referenced_patterns(tops) - set((None,)) # type: ignore
|
||||
|
||||
new = type(self)()
|
||||
for key in keep:
|
||||
new._merge(self, key)
|
||||
return new
|
||||
|
||||
|
||||
class WrapROLibrary(Library):
|
||||
mapping: Mapping[str, Pattern]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
mapping: Mapping[str, Pattern],
|
||||
) -> None:
|
||||
self.mapping = mapping
|
||||
|
||||
def __getitem__(self, key: str) -> 'Pattern':
|
||||
return self.mapping[key]
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
return iter(self.mapping)
|
||||
|
||||
def __len__(self) -> int:
|
||||
return len(self.mapping)
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f'<WrapROLibrary ({type(self.mapping)}) with keys ' + repr(list(self.keys())) + '>'
|
||||
|
||||
|
||||
class WrapLibrary(MutableLibrary):
|
||||
mapping: MutableMapping[str, Pattern]
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
mapping: MutableMapping[str, Pattern],
|
||||
) -> None:
|
||||
self.mapping = mapping
|
||||
|
||||
def __getitem__(self, key: str) -> 'Pattern':
|
||||
return self.mapping[key]
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
return iter(self.mapping)
|
||||
|
||||
def __len__(self) -> int:
|
||||
return len(self.mapping)
|
||||
|
||||
def __setitem__(self, key: str, value: Pattern) -> None:
|
||||
self.mapping[key] = value
|
||||
|
||||
def __delitem__(self, key: str) -> None:
|
||||
del self.mapping[key]
|
||||
|
||||
def _set(self, key: str, value: Pattern) -> None:
|
||||
self[key] = value
|
||||
|
||||
def _merge(self: ML, other: L, key: str) -> None:
|
||||
self[key] = other[key]
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return f'<WrapLibrary ({type(self.mapping)}) with keys ' + repr(list(self.keys())) + '>'
|
||||
|
||||
|
||||
class LazyLibrary(MutableLibrary):
|
||||
"""
|
||||
This class is usually used to create a library of Patterns by mapping names to
|
||||
functions which generate or load the relevant `Pattern` object as-needed.
|
||||
|
||||
The cache can be disabled by setting the `enable_cache` attribute to `False`.
|
||||
"""
|
||||
dict: Dict[str, Callable[[], Pattern]]
|
||||
cache: Dict[str, 'Pattern']
|
||||
enable_cache: bool = True
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.dict = {}
|
||||
self.cache = {}
|
||||
|
||||
def __setitem__(self, key: str, value: Callable[[], Pattern]) -> None:
|
||||
self.dict[key] = value
|
||||
if key in self.cache:
|
||||
del self.cache[key]
|
||||
|
||||
def __delitem__(self, key: str) -> None:
|
||||
del self.dict[key]
|
||||
if key in self.cache:
|
||||
del self.cache[key]
|
||||
|
||||
def __getitem__(self, key: str) -> 'Pattern':
|
||||
logger.debug(f'loading {key}')
|
||||
if self.enable_cache and key in self.cache:
|
||||
logger.debug(f'found {key} in cache')
|
||||
return self.cache[key]
|
||||
|
||||
func = self.dict[key]
|
||||
pat = func()
|
||||
self.cache[key] = pat
|
||||
return pat
|
||||
|
||||
def __iter__(self) -> Iterator[str]:
|
||||
return iter(self.dict)
|
||||
|
||||
def __len__(self) -> int:
|
||||
return len(self.dict)
|
||||
|
||||
def _set(self, key: str, value: Pattern) -> None:
|
||||
self[key] = lambda: value
|
||||
|
||||
def _merge(self: LL, other: L, key: str) -> None:
|
||||
if type(self) is type(other):
|
||||
self.dict[key] = other.dict[key]
|
||||
if key in other.cache:
|
||||
self.cache[key] = other.cache[key]
|
||||
else:
|
||||
self._set(key, other[key])
|
||||
|
||||
def __repr__(self) -> str:
|
||||
return '<LazyLibrary with keys ' + repr(list(self.dict.keys())) + '>'
|
||||
|
||||
def precache(self: L) -> L:
|
||||
"""
|
||||
Force all patterns into the cache
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
for key in self.dict:
|
||||
_ = self.dict.__getitem__(key)
|
||||
return self
|
||||
|
||||
def clear_cache(self: L) -> L:
|
||||
"""
|
||||
Clear the cache of this library.
|
||||
This is usually used before modifying or deleting cells, e.g. when merging
|
||||
with another library.
|
||||
|
||||
Returns:
|
||||
self
|
||||
"""
|
||||
self.cache.clear()
|
||||
return self
|
||||
|
||||
def __deepcopy__(self, memo: Dict = None) -> 'LazyLibrary':
|
||||
raise LibraryError('LazyLibrary cannot be deepcopied (deepcopy doesn\'t descend into closures)')
|
||||
|
||||
Loading…
Reference in New Issue
Block a user