Changeset 44

Timestamp:

02/23/08 13:44:09 (9 months ago)

Author:

erik

Message:

This implements add, sub, mul, rmul, div and rdiv for psHints. With a tip of the hat to Tal's fontMath for some ideas. This also includes a round() method which does some appropriate rounding and integerifying of the zone and stems.

Files:

• trunk/robofab/Lib/robofab/objects/objectsBase.py (modified) (8 diffs)

trunk/robofab/Lib/robofab/objects/objectsBase.py

@@ -1 @@
-    
+ 
-Base classes for the Unified Font Objects (UFO),
-a series of classes that deal with fonts, glyphs,
@@ -17 +17 @@
-
-from __future__ import generators
+from __future__ import division
-
-
@@ -40 +41 @@
-postScriptHintDataLibKey = "org.robofab.postScriptHintData"
-
+# from http://svn.typesupply.com/packages/fontMath/mathFunctions.py
+
+def add(v1, v2):
+        return v1 + v2
+
+def sub(v1, v2):
+        return v1 - v2
+
+def mul(v, f):
+        return v * f
+
+def div(v, f):
+        return v / f
+        
+def issequence(x):
+        "Is x a sequence? We say it is if it has a __getitem__ method."
+        return hasattr(x, '__getitem__')
+
-
-class BasePostScriptFontHintValues(object):
@@ -46 +65 @@
-        """
-        
-
+ibuteName
-                # some of these values can have only a certain number of elements
- 
- 
- 
- 
-  {'default': None, 'max':13
-  {'default': None, 'max':9
-         {'default': None, 'max':13
-9
-              {'default': None, 'max':11
- 
+    
+
+
+
+  {'default': None, 'max':7
+  {'default': None, 'max':5
+ {'default': None, 'max':7
+5
+              {'default': None, 'max':6
+
-                }
-                
-
-
-
+
+
+
+
+
+
-                
-        def getParent(self):
@@ -73 +95 @@
-
-        def fromDict(self, data):
-
+ibuteName
-                        if name in data:
-                                setattr(self, name, data[name])
@@ -79 +101 @@
-        def asDict(self):
-                d = {}
-
+ibuteName
-                        try:
-                                value = getattr(self, name)
@@ -89 +111 @@
-                return d
-        
+        def update(self, other):
+                assert isinstance(other, BasePostScriptFontHintValues)
+                for name in self._attributeNames.keys():
+                        v = getattr(other, name)
+                        if v is not None:
+                                setattr(self, name, v)
+
-        def __repr__(self):
-                return "<PostScript Font Hints Values>"
+
+        def copy(self, aParent=None):
+                """Duplicate this object. Pass an object for parenting if you want."""
+                n = self.__class__(data=self.asDict())
+                if aParent is not None:
+                        n.setParent(aParent)
+                elif self.getParent() is not None:
+                        n.setParent(self.getParent())
+                dont = ['getParent']
+                for k in self.__dict__.keys():
+                        if k in dont:
+                                continue
+                        dup = copy.deepcopy(self.__dict__[k])
+                        setattr(n, k, dup)
+                return n
+
+        def round(self):
+                """Round the values to reasonable values.
+                        - blueScale is not rounded, it is a float
+                        - forceBold is set to False if -0.5 < value < 0.5. Otherwise it will be True.
+                        - blueShift, blueFuzz are rounded to int
+                        - stems are rounded to int
+                        - blues are rounded to int
+                """
+                for name, values in self._attributeNames.items():
+                        if name == "blueScale":
+                                continue
+                        elif name == "forceBold":
+                                v = getattr(self, name)
+                                if v is None:
+                                        continue
+                                if -0.5 <= v <= 0.5:
+                                        setattr(self, name, False)
+                                else:
+                                        setattr(self, name, True)
+                        elif name in ['blueFuzz', 'blueShift']:
+                                v = getattr(self, name)
+                                if v is None:
+                                        continue
+                                setattr(self, name, int(round(v)))
+                        elif name in ['hStems', 'vStems']:
+                                v = getattr(self, name)
+                                if v is None:
+                                        continue
+                                new = []
+                                for n in v:
+                                        new.append(int(round(n)))
+                                setattr(self, name, new)
+                        else:
+                                v = getattr(self, name)
+                                if v is None:
+                                        continue
+                                new = []
+                                for n in v:
+                                        new.append([int(round(m)) for m in n])
+                                setattr(self, name, new)
+        
+        # math operations for psHint object
+        def __add__(self, other):
+                assert isinstance(other, BasePostScriptFontHintValues)
+                copied = self.copy()
+                self._processMathOne(copied, other, add)
+                return copied
+
+        def __sub__(self, other):
+                assert isinstance(other, BasePostScriptFontHintValues)
+                copied = self.copy()
+                self._processMathOne(copied, other, sub)
+                return copied
+
+        def __mul__(self, factor):
+                if isinstance(factor, tuple):
+                        factor = factor[0]
+                copiedInfo = self.copy()
+                self._processMathTwo(copiedInfo, factor, mul)
+                return copiedInfo
+
+        __rmul__ = __mul__
+
+        def __div__(self, factor):
+                if isinstance(factor, tuple):
+                        factor = factor[0]
+                copiedInfo = self.copy()
+                self._processMathTwo(copiedInfo, factor, mul)
+                return copiedInfo
+
+        __rdiv__ = __div__
+        
+        def _processMathOne(self, copied, other, funct):
+                for name, values in self._attributeNames.items():
+                        a = None
+                        b = None
+                        v = None
+                        if hasattr(copied, name):
+                                a = getattr(copied, name)
+                        if hasattr(other, name):
+                                b = getattr(other, name)
+                        if name in ['blueFuzz', 'blueScale', 'blueShift', 'forceBold']:
+                                # process single values
+                                if a is not None and b is not None:
+                                        v = funct(a, b)
+                                elif a is not None and b is None:
+                                        v = a
+                                elif b is not None and a is None:
+                                        v = b
+                                if v is not None:
+                                        setattr(copied, name, v)
+                        elif name in ['hStems', 'vStems']:
+                                if a is not None and b is not None:
+                                        l = min(len(a), len(b))
+                                        v = [funct(a[i], b[i]) for i in range(l)]
+                                if v is not None:
+                                        setattr(copied, name, v)
+                        else:
+                                if a is not None and b is not None:
+                                        l = min(len(a), len(b))
+                                        for i in range(l):
+                                                if v is None:
+                                                        v = []
+                                                ai = a[i]
+                                                bi = b[i]
+                                                l2 = min(len(ai), len(bi))
+                                                v2 = [funct(ai[j], bi[j]) for j in range(l2)]
+                                                v.append(v2)
+                                if v is not None:
+                                        setattr(copied, name, v)
+
+        def _processMathTwo(self, copied, factor, funct):
+                for name, values in self._attributeNames.items():
+                        a = None
+                        b = None
+                        v = None
+                        if hasattr(copied, name):
+                                a = getattr(copied, name)
+                        if name in ['blueFuzz', 'blueScale', 'blueShift', 'forceBold']:
+                                # process single values
+                                if a is not None:
+                                        v = funct(a, factor)
+                                if v is not None:
+                                        setattr(copied, name, v)
+                        elif name in ['hStems', 'vStems']:
+                                if a is not None:
+                                        v = [funct(a[i], factor) for i in range(len(a))]
+                                if v is not None:
+                                        setattr(copied, name, v)
+                        else:
+                                if a is not None:
+                                        for i in range(len(a)):
+                                                if v is None:
+                                                        v = []
+                                                v2 = [funct(a[i][j], factor) for j in range(len(a[i]))]
+                                                v.append(v2)
+                                if v is not None:
+                                        setattr(copied, name, v)
+
-
-
@@ -1319 +1503 @@
-                It returns a list of lists containing bool values
-                that indicate the black (True) or white (False)
-  
+ 
-                arranged from top to bottom of the glyph and
-                proceed from left to right.