| | from fontTools.varLib.models import VariationModel, normalizeValue, piecewiseLinearMap |
| |
|
| |
|
| | def Location(loc): |
| | return tuple(sorted(loc.items())) |
| |
|
| |
|
| | class VariableScalar: |
| | """A scalar with different values at different points in the designspace.""" |
| |
|
| | def __init__(self, location_value={}): |
| | self.values = {} |
| | self.axes = {} |
| | for location, value in location_value.items(): |
| | self.add_value(location, value) |
| |
|
| | def __repr__(self): |
| | items = [] |
| | for location, value in self.values.items(): |
| | loc = ",".join(["%s=%i" % (ax, loc) for ax, loc in location]) |
| | items.append("%s:%i" % (loc, value)) |
| | return "(" + (" ".join(items)) + ")" |
| |
|
| | @property |
| | def does_vary(self): |
| | values = list(self.values.values()) |
| | return any(v != values[0] for v in values[1:]) |
| |
|
| | @property |
| | def axes_dict(self): |
| | if not self.axes: |
| | raise ValueError( |
| | ".axes must be defined on variable scalar before interpolating" |
| | ) |
| | return {ax.axisTag: ax for ax in self.axes} |
| |
|
| | def _normalized_location(self, location): |
| | location = self.fix_location(location) |
| | normalized_location = {} |
| | for axtag in location.keys(): |
| | if axtag not in self.axes_dict: |
| | raise ValueError("Unknown axis %s in %s" % (axtag, location)) |
| | axis = self.axes_dict[axtag] |
| | normalized_location[axtag] = normalizeValue( |
| | location[axtag], (axis.minValue, axis.defaultValue, axis.maxValue) |
| | ) |
| |
|
| | return Location(normalized_location) |
| |
|
| | def fix_location(self, location): |
| | location = dict(location) |
| | for tag, axis in self.axes_dict.items(): |
| | if tag not in location: |
| | location[tag] = axis.defaultValue |
| | return location |
| |
|
| | def add_value(self, location, value): |
| | if self.axes: |
| | location = self.fix_location(location) |
| |
|
| | self.values[Location(location)] = value |
| |
|
| | def fix_all_locations(self): |
| | self.values = { |
| | Location(self.fix_location(l)): v for l, v in self.values.items() |
| | } |
| |
|
| | @property |
| | def default(self): |
| | self.fix_all_locations() |
| | key = Location({ax.axisTag: ax.defaultValue for ax in self.axes}) |
| | if key not in self.values: |
| | raise ValueError("Default value could not be found") |
| | |
| | return self.values[key] |
| |
|
| | def value_at_location(self, location, model_cache=None, avar=None): |
| | loc = Location(location) |
| | if loc in self.values.keys(): |
| | return self.values[loc] |
| | values = list(self.values.values()) |
| | loc = dict(self._normalized_location(loc)) |
| | return self.model(model_cache, avar).interpolateFromMasters(loc, values) |
| |
|
| | def model(self, model_cache=None, avar=None): |
| | if model_cache is not None: |
| | key = tuple(self.values.keys()) |
| | if key in model_cache: |
| | return model_cache[key] |
| | locations = [dict(self._normalized_location(k)) for k in self.values.keys()] |
| | if avar is not None: |
| | mapping = avar.segments |
| | locations = [ |
| | { |
| | k: piecewiseLinearMap(v, mapping[k]) if k in mapping else v |
| | for k, v in location.items() |
| | } |
| | for location in locations |
| | ] |
| | m = VariationModel(locations) |
| | if model_cache is not None: |
| | model_cache[key] = m |
| | return m |
| |
|
| | def get_deltas_and_supports(self, model_cache=None, avar=None): |
| | values = list(self.values.values()) |
| | return self.model(model_cache, avar).getDeltasAndSupports(values) |
| |
|
| | def add_to_variation_store(self, store_builder, model_cache=None, avar=None): |
| | deltas, supports = self.get_deltas_and_supports(model_cache, avar) |
| | store_builder.setSupports(supports) |
| | index = store_builder.storeDeltas(deltas) |
| | return int(self.default), index |
| |
|
