[italics] Fix whitespace

3 files changed, 83 insertions, 65 deletions

diff --git a/scripts/lib/fontbuild/alignpoints.py b/scripts/lib/fontbuild/alignpoints.py
index 1133716..76581a5 100644
--- a/scripts/lib/fontbuild/alignpoints.py
+++ b/scripts/lib/fontbuild/alignpoints.py
@@ -28,7 +28,7 @@ def alignCorners(glyph, va, subsegments):
     #             if seg.type == "line":
     #                 subIndex = subsegmentIndex(i,j,subsegments)
     #                 out[subIndex] = alignPoints(va[subIndex])
-    
+
     for i,c in enumerate(subsegments):
         segmentCount = len(glyph.contours[i].segments)
         n = len(c)
@@ -66,7 +66,7 @@ def alignCorners(glyph, va, subsegments):
 
 def subsegmentIndex(contourIndex, segmentIndex, subsegments):
     # This whole thing is so dumb. Need a better data model for subsegments
-    
+
     contourOffset = 0
     for i,c in enumerate(subsegments):
         if i == contourIndex:
@@ -77,10 +77,11 @@ def subsegmentIndex(contourIndex, segmentIndex, subsegments):
     startIndex = subsegments[contourIndex][segmentIndex-1][0]
     segmentCount = subsegments[contourIndex][segmentIndex][1]
     endIndex = (startIndex + segmentCount + 1) % (n)
-    
+
     indices = np.array([(startIndex + i) % (n) + contourOffset for i in range(segmentCount + 1)])
     return indices
 
+
 def alignPoints(pts, start=None, end=None):
     if start == None or end == None:
         start, end = fitLine(pts)
@@ -89,6 +90,7 @@ def alignPoints(pts, start=None, end=None):
         out[i] = nearestPoint(start, end, p)
     return out
 
+
 def findCorner(pp, nn):
     if len(pp) < 4 or len(nn) < 4:
         assert 0, "line too short to fit"
@@ -96,34 +98,36 @@ def findCorner(pp, nn):
     nStart,nEnd = fitLine(nn)
     prev = pEnd - pStart
     next = nEnd - nStart
-    # print int(np.arctan2(prev[1],prev[0]) / math.pi * 180), 
+    # print int(np.arctan2(prev[1],prev[0]) / math.pi * 180),
     # print int(np.arctan2(next[1],next[0]) / math.pi * 180)
     # if lines are parallel, return simple average of end and start points
-    if np.dot(prev / np.linalg.norm(prev), 
+    if np.dot(prev / np.linalg.norm(prev),
               next / np.linalg.norm(next)) > .999999:
         # print "parallel lines", np.arctan2(prev[1],prev[0]), np.arctan2(next[1],next[0])
         # print prev, next
         assert 0, "parallel lines"
     return lineIntersect(pStart, pEnd, nStart, nEnd)
 
+
 def lineIntersect((x1,y1),(x2,y2),(x3,y3),(x4,y4)):
     x12 = x1 - x2
     x34 = x3 - x4
     y12 = y1 - y2
     y34 = y3 - y4
-    
+
     det = x12 * y34 - y12 * x34
     if det == 0:
         print "parallel!"
-        
+
     a = x1 * y2 - y1 * x2
     b = x3 * y4 - y3 * x4
-    
+
     x = (a * x34 - b * x12) / det
     y = (a * y34 - b * y12) / det
-    
+
     return (x,y)
 
+
 def fitLineLSQ(pts):
     "returns a line fit with least squares. Fails for vertical lines"
     n = len(pts)
@@ -133,6 +137,7 @@ def fitLineLSQ(pts):
     line = lstsq(a,pts[:,1])[0]
     return line
 
+
 def fitLine(pts):
     """returns a start vector and direction vector
     Assumes points segments that already form a somewhat smooth line
@@ -147,7 +152,8 @@ def fitLine(pts):
     direction = np.mean(a[1:-1], axis=0)
     start = np.mean(pts[1:-1], axis=0)
     return start, start+direction
-    
+
+
 def nearestPoint(a,b,c):
     "nearest point to point c on line a_b"
     magnitude = np.linalg.norm(b-a)
@@ -155,6 +161,7 @@ def nearestPoint(a,b,c):
         raise Exception, "Line segment cannot be 0 length"
     return (b-a) * np.dot((c-a) / magnitude, (b-a) / magnitude) + a
 
+
 # pts = np.array([[1,1],[2,2],[3,3],[4,4]])
 # pts2 = np.array([[1,0],[2,0],[3,0],[4,0]])
 # print alignPoints(pts2, start = pts[0], end = pts[0]+pts[0])
diff --git a/scripts/lib/fontbuild/curveFitPen.py b/scripts/lib/fontbuild/curveFitPen.py
index 7c232c0..6ef42da 100644
--- a/scripts/lib/fontbuild/curveFitPen.py
+++ b/scripts/lib/fontbuild/curveFitPen.py
@@ -17,6 +17,7 @@
 
 __all__ = ["SubsegmentPen","SubsegmentsToCurvesPen", "segmentGlyph", "fitGlyph"]
 
+
 from fontTools.pens.basePen import BasePen
 from fontTools.misc import bezierTools
 from robofab.pens.pointPen import AbstractPointPen
@@ -27,15 +28,17 @@ from numpy import array as v
 from random import random
 
 from robofab.pens.pointPen import BasePointToSegmentPen
+
+
 class SubsegmentsToCurvesPointPen(BasePointToSegmentPen):
     def __init__(self, glyph, subsegmentGlyph, subsegments):
         BasePointToSegmentPen.__init__(self)
         self.glyph = glyph
         self.subPen = SubsegmentsToCurvesPen(None, glyph.getPen(), subsegmentGlyph, subsegments)
-        
+
     def setMatchTangents(self, b):
         self.subPen.matchTangents = b
-        
+
     def _flushContour(self, segments):
         #
         # adapted from robofab.pens.adapterPens.rfUFOPointPen
@@ -56,13 +59,13 @@ class SubsegmentsToCurvesPointPen(BasePointToSegmentPen):
                 self.subPen.setLastSmooth(True)
             if segmentType == 'line':
                     del segments[-1]
-                    
+
         self.subPen.moveTo(movePt)
-        
+
         # do the rest of the segments
         for segmentType, points in segments:
             isSmooth = True in [smooth for pt, smooth, name, kwargs in points]
-            pp = [pt for pt, smooth, name, kwargs in points]            
+            pp = [pt for pt, smooth, name, kwargs in points]
             if segmentType == "line":
                     assert len(pp) == 1
                     if isSmooth:
@@ -73,17 +76,18 @@ class SubsegmentsToCurvesPointPen(BasePointToSegmentPen):
                     assert len(pp) == 3
                     if isSmooth:
                         self.subPen.smoothCurveTo(*pp)
-                    else: 
+                    else:
                         self.subPen.curveTo(*pp)
             elif segmentType == "qcurve":
                     assert 0, "qcurve not supported"
             else:
                     assert 0, "illegal segmentType: %s" % segmentType
         self.subPen.closePath()
-    
+
     def addComponent(self, glyphName, transform):
         self.subPen.addComponent(glyphName, transform)
 
+
 class SubsegmentsToCurvesPen(BasePen):
     def __init__(self, glyphSet, otherPen, subsegmentGlyph, subsegments):
         BasePen.__init__(self, None)
@@ -95,10 +99,10 @@ class SubsegmentsToCurvesPen(BasePen):
         self.lastPoint = (0,0)
         self.lastSmooth = False
         self.nextSmooth = False
-    
+
     def setLastSmooth(self, b):
         self.lastSmooth = b
-        
+
     def _moveTo(self, (x, y)):
         self.contourIndex += 1
         self.segmentIndex = 0
@@ -106,7 +110,7 @@ class SubsegmentsToCurvesPen(BasePen):
         p = self.ssglyph.contours[self.contourIndex][0].points[0]
         self.otherPen.moveTo((p.x, p.y))
         self.lastPoint = (x,y)
-    
+
     def _lineTo(self, (x, y)):
         self.segmentIndex += 1
         index = self.subsegments[self.contourIndex][self.segmentIndex][0]
@@ -114,39 +118,39 @@ class SubsegmentsToCurvesPen(BasePen):
         self.otherPen.lineTo((p.x, p.y))
         self.lastPoint = (x,y)
         self.lastSmooth = False
-    
+
     def smoothLineTo(self, (x, y)):
         self.lineTo((x,y))
         self.lastSmooth = True
-    
+
     def smoothCurveTo(self, (x1, y1), (x2, y2), (x3, y3)):
         self.nextSmooth = True
         self.curveTo((x1, y1), (x2, y2), (x3, y3))
         self.nextSmooth = False
         self.lastSmooth = True
-    
-    def _curveToOne(self, (x1, y1), (x2, y2), (x3, y3)):    
+
+    def _curveToOne(self, (x1, y1), (x2, y2), (x3, y3)):
         self.segmentIndex += 1
         c = self.ssglyph.contours[self.contourIndex]
         n = len(c)
         startIndex = (self.subsegments[self.contourIndex][self.segmentIndex-1][0])
         segmentCount = (self.subsegments[self.contourIndex][self.segmentIndex][1])
         endIndex = (startIndex + segmentCount + 1) % (n)
-        
+
         indices = [(startIndex + i) % (n) for i in range(segmentCount + 1)]
         points = np.array([(c[i].points[0].x, c[i].points[0].y) for i in indices])
         prevPoint = (c[(startIndex - 1)].points[0].x, c[(startIndex - 1)].points[0].y)
         nextPoint = (c[(endIndex) % n].points[0].x, c[(endIndex) % n].points[0].y)
         prevTangent = prevPoint - points[0]
         nextTangent = nextPoint - points[-1]
-        
+
         tangent1 = points[1] - points[0]
         tangent3 = points[-2] - points[-1]
         prevTangent /= np.linalg.norm(prevTangent)
         nextTangent /= np.linalg.norm(nextTangent)
         tangent1 /= np.linalg.norm(tangent1)
         tangent3 /= np.linalg.norm(tangent3)
-        
+
         tangent1, junk = self.smoothTangents(tangent1, prevTangent, self.lastSmooth)
         tangent3, junk = self.smoothTangents(tangent3, nextTangent, self.nextSmooth)
         if self.matchTangents == True:
@@ -162,7 +166,7 @@ class SubsegmentsToCurvesPen(BasePen):
         self.otherPen.curveTo((cp[1,0], cp[1,1]), (cp[2,0], cp[2,1]), (cp[3,0], cp[3,1]))
         self.lastPoint = (x3, y3)
         self.lastSmooth = False
-    
+
     def smoothTangents(self,t1,t2,forceSmooth = False):
         if forceSmooth or (abs(t1.dot(t2)) > .95 and norm(t1-t2) > 1):
             # print t1,t2,
@@ -170,15 +174,13 @@ class SubsegmentsToCurvesPen(BasePen):
             t2 = -t1
             # print t1,t2
         return t1 / norm(t1), t2 / norm(t2)
-    
-    
+
     def _closePath(self):
         self.otherPen.closePath()
-    
+
     def _endPath(self):
         self.otherPen.endPath()
-    
-    
+
     def addComponent(self, glyphName, transformation):
         self.otherPen.addComponent(glyphName, transformation)
 
@@ -189,10 +191,10 @@ class SubsegmentPointPen(BasePointToSegmentPen):
         self.glyph = glyph
         self.resolution = resolution
         self.subPen = SubsegmentPen(None, glyph.getPen())
-        
+
     def getSubsegments(self):
         return self.subPen.subsegments[:]
-        
+
     def _flushContour(self, segments):
         #
         # adapted from robofab.pens.adapterPens.rfUFOPointPen
@@ -210,9 +212,9 @@ class SubsegmentPointPen(BasePointToSegmentPen):
             movePt, smooth, name, kwargs = points[-1]
             if segmentType == 'line':
                     del segments[-1]
-                    
+
         self.subPen.moveTo(movePt)
-        
+
         # do the rest of the segments
         for segmentType, points in segments:
             points = [pt for pt, smooth, name, kwargs in points]
@@ -227,12 +229,13 @@ class SubsegmentPointPen(BasePointToSegmentPen):
             else:
                     assert 0, "illegal segmentType: %s" % segmentType
         self.subPen.closePath()
-    
+
     def addComponent(self, glyphName, transform):
         self.subPen.addComponent(glyphName, transform)
 
+
 class SubsegmentPen(BasePen):
-    
+
     def __init__(self, glyphSet, otherPen, resolution=25):
         BasePen.__init__(self,glyphSet)
         self.resolution = resolution
@@ -240,7 +243,7 @@ class SubsegmentPen(BasePen):
         self.subsegments = []
         self.startContour = (0,0)
         self.contourIndex = -1
-    
+
     def _moveTo(self, (x, y)):
         self.contourIndex += 1
         self.segmentIndex = 0
@@ -250,7 +253,7 @@ class SubsegmentPen(BasePen):
         self.startContour = (x,y)
         self.lastPoint = (x,y)
         self.otherPen.moveTo((x,y))
-        
+
     def _lineTo(self, (x, y)):
         count = self.stepsForSegment((x,y),self.lastPoint)
         if count < 1:
@@ -262,7 +265,7 @@ class SubsegmentPen(BasePen):
             y1 = self.lastPoint[1] + (y - self.lastPoint[1]) * i/float(count)
             self.otherPen.lineTo((x1,y1))
         self.lastPoint = (x,y)
-    
+
     def _curveToOne(self, (x1, y1), (x2, y2), (x3, y3)):
         count = self.stepsForSegment((x3,y3),self.lastPoint)
         if count < 2:
@@ -277,46 +280,45 @@ class SubsegmentPen(BasePen):
         for i in range(count):
             self.otherPen.lineTo((x[i],y[i]))
         self.lastPoint = (x3,y3)
-    
+
     def _closePath(self):
         if not (self.lastPoint[0] == self.startContour[0] and self.lastPoint[1] == self.startContour[1]):
             self._lineTo(self.startContour)
         self.otherPen.closePath()
-    
+
     def _endPath(self):
         self.otherPen.endPath()
-    
+
     def addComponent(self, glyphName, transformation):
         self.otherPen.addComponent(glyphName, transformation)
-    
+
     def stepsForSegment(self, p1, p2):
         dist = np.linalg.norm(v(p1) - v(p2))
         out = int(dist / self.resolution)
         return out
-    
+
     def renderCurve(self,p,count):
         curvePoints = []
         t = 1.0 / float(count)
         temp = t * t
-        
+
         f = p[0]
         fd = 3 * (p[1] - p[0]) * t
         fdd_per_2 = 3 * (p[0] - 2 * p[1] + p[2]) * temp
         fddd_per_2 = 3 * (3 * (p[1] - p[2]) + p[3] - p[0]) * temp * t
-        
+
         fddd = fddd_per_2 + fddd_per_2
         fdd = fdd_per_2 + fdd_per_2
         fddd_per_6 = fddd_per_2 * (1.0 / 3)
-        
+
         for i in range(count):
             f = f + fd + fdd_per_2 + fddd_per_6
             fd = fd + fdd + fddd_per_2
             fdd = fdd + fddd
             fdd_per_2 = fdd_per_2 + fddd_per_2
             curvePoints.append(f)
-        
-        return curvePoints
 
+        return curvePoints
 
 
 def fitBezierSimple(pts):
@@ -363,14 +365,14 @@ def fitBezier(pts,tangent0=None,tangent3=None):
     pout = pts.copy()
     pout[:,0] -= (T[:,0] * pts[0,0]) + (T[:,3] * pts[-1,0])
     pout[:,1] -= (T[:,0] * pts[0,1]) + (T[:,3] * pts[-1,1])
-        
+
     TT = np.zeros((n*2,4))
     for i in range(n):
         for j in range(2):
             TT[i*2,j*2] = T[i,j+1]
             TT[i*2+1,j*2+1] = T[i,j+1]
     pout = pout.reshape((n*2,1),order="C")
-    
+
     if tangent0 != None and tangent3 != None:
         tangentConstraintsT = np.array([
                 [tangent0[1], -tangent0[0], 0, 0],
@@ -414,4 +416,3 @@ if __name__ == '__main__':
         [1,1]
     ])
     print np.array(p.renderCurve(pts,10)) * 10
-    
diff --git a/scripts/lib/fontbuild/italics.py b/scripts/lib/fontbuild/italics.py
index c889bd5..b1db984 100644
--- a/scripts/lib/fontbuild/italics.py
+++ b/scripts/lib/fontbuild/italics.py
@@ -33,11 +33,11 @@ def italicizeGlyph(f, g, angle=10, stemWidth=185):
     m = Transform(1, 0, slope, 1, 0, 0)
     xoffset, junk = m.transformPoint((0, MEAN_YCENTER))
     m = Transform(.97, 0, slope, 1, xoffset, 0)
-    
+
     if len(glyph) > 0:
         g2 = italicize(f[g.name], angle, xoffset=xoffset, stemWidth=stemWidth)
         f.insertGlyph(g2, g.name)
-        
+
     transformFLGlyphMembers(f[g.name], m)
 
     if unic > 0xFFFF: #restore unicode
@@ -53,12 +53,12 @@ def italicize(glyph, angle=12, stemWidth=180, xoffset=-50):
     grad = mapEdges(lambda a,(p,n): normalize(p-a), va, e)
     cornerWeights = mapEdges(lambda a,(p,n): normalize(p-a).dot(normalize(a-n)), grad, e)[:,0].reshape((-1,1))
     smooth = np.ones((n,1)) * CURVE_CORRECTION_WEIGHT
-    
+
     controlPoints = findControlPointsInMesh(glyph, va, subsegments)
     smooth[controlPoints > 0] = 1
     smooth[cornerWeights < .6] = CORNER_WEIGHT
     # smooth[cornerWeights >= .9999] = 1
-    
+
     out = va.copy()
     hascurves = False
     for c in glyph.contours:
@@ -80,13 +80,13 @@ def italicize(glyph, angle=12, stemWidth=180, xoffset=-50):
     centerSkew = skewMesh(center.dot(np.array([[.97,0],[0,1]])), angle * .9)
     out = outCorrected + (centerSkew - center)
     out[:,1] = outCorrected[:,1]
-    
+
     smooth = np.ones((n,1)) * .1
     out = alignCorners(glyph, out, subsegments)
     out = copyMeshDetails(skewMesh(va, angle), out, e, 7, smooth=smooth)
     # grad = mapEdges(lambda a,(p,n): normalize(p-a), skewMesh(outCorrected, angle*.9), e)
     # out = recompose(out, grad, e, smooth=smooth)
-    
+
     out = skewMesh(out, angle * .1)
     out[:,0] += xoffset
     # out[:,1] = outCorrected[:,1]
@@ -132,6 +132,7 @@ def glyphToMesh(g):
         offset += len(c)
     return np.array(points), edges
 
+
 def meshToGlyph(points, g):
     g1 = g.copy()
     j = 0
@@ -144,6 +145,7 @@ def meshToGlyph(points, g):
             j += 1
     return g1
 
+
 def quantizeGradient(grad, book=None):
     if book == None:
         book = np.array([(1,0),(0,1),(0,-1),(-1,0)])
@@ -153,6 +155,7 @@ def quantizeGradient(grad, book=None):
         out[i] = normalize(v)
     return out
 
+
 def findControlPointsInMesh(glyph, va, subsegments):
     controlPointIndices = np.zeros((len(va),1))
     index = 0
@@ -166,7 +169,6 @@ def findControlPointsInMesh(glyph, va, subsegments):
     return controlPointIndices
 
 
-
 def recompose(v, grad, e, smooth=1, P=None, distance=None):
     n = len(v)
     if distance == None:
@@ -183,6 +185,7 @@ def recompose(v, grad, e, smooth=1, P=None, distance=None):
         out[:,i] = cg(P, f[:,i])[0]
     return out
 
+
 def mP(v,e):
     n = len(v)
     M = np.zeros((n,n))
@@ -193,18 +196,21 @@ def mP(v,e):
         M[i,i] = 2
     return M
 
+
 def normalize(v):
     n = np.linalg.norm(v)
     if n == 0:
         return v
     return v/n
 
+
 def mapEdges(func,v,e,*args):
     b = v.copy()
     for i, edges in e.iteritems():
         b[i] = func(v[i], [v[j] for j in edges], *args)
     return b
 
+
 def getNormal(a,b,c):
     "Assumes TT winding direction"
     p = np.roll(normalize(b - a), 1)
@@ -214,19 +220,23 @@ def getNormal(a,b,c):
     # print p, n, normalize((p + n) * .5)
     return normalize((p + n) * .5)
 
+
 def edgeNormals(v,e):
     "Assumes a mesh where each vertex has exactly least two edges"
     return mapEdges(lambda a,(p,n) : getNormal(a,p,n),v,e)
 
+
 def rangePrevNext(count):
     c = np.arange(count,dtype=int)
     r = np.vstack((c, np.roll(c, 1), np.roll(c, -1)))
     return r.T
 
+
 def skewMesh(v,angle):
     slope = np.tanh([math.pi * angle / 180])
     return v.dot(np.array([[1,0],[slope,1]]))
 
+
 def labelConnected(e):
     label = 0
     labels = np.zeros((len(e),1))
@@ -236,6 +246,7 @@ def labelConnected(e):
             label += 1
     return labels
 
+
 def copyGradDetails(a,b,e,scale=15):
     n = len(a)
     labels = labelConnected(e)
@@ -245,6 +256,7 @@ def copyGradDetails(a,b,e,scale=15):
         out[mask,:] = gaussian(b[mask,:], scale, mode="wrap", axis=0) + a[mask,:] - gaussian(a[mask,:], scale, mode="wrap", axis=0)
     return out
 
+
 def copyMeshDetails(va,vb,e,scale=5,smooth=.01):
     gradA = mapEdges(lambda a,(p,n): normalize(p-a), va, e)
     gradB = mapEdges(lambda a,(p,n): normalize(p-a), vb, e)
@@ -253,8 +265,6 @@ def copyMeshDetails(va,vb,e,scale=5,smooth=.01):
     return recompose(vb, grad, e, smooth=smooth)
 
 
-
-
 def condenseGlyph(glyph, scale=.8, stemWidth=185):
     ga, subsegments = segmentGlyph(glyph, 25)
     va, e  = glyphToMesh(ga)
@@ -273,7 +283,7 @@ def condenseGlyph(glyph, scale=.8, stemWidth=185):
     # cornerWeights = mapEdges(lambda a,(p,n): normalize(p-a).dot(normalize(a-n)), grad, e)[:,0].reshape((-1,1))
     #     smooth = np.ones((n,1)) * .1
     #     smooth[cornerWeights < .6] = 10
-    #     
+    #
     #     grad2 = quantizeGradient(grad).astype(float)
     #     grad2 = copyGradDetails(grad, grad2, e, scale=10)
     #     grad2 = mapEdges(lambda a,e: normalize(a), grad2, e)