Tunnify.py

#MenuTitle: Tunnify
# -*- coding: utf-8 -*-
from __future__ import division, print_function, unicode_literals
__doc__="""
Averages out the handles of selected path segments (or all paths if nothing is selected or multiple glyphs are selected). Doing this is a good idea for zero handles, and as preparation for interpolation. If you just want to fix zero handles, then check out the FixZeroHandles plugin in Window > Plugin Manager.
"""

from Foundation import NSPoint

tunnifiedZeroLo = 0.43
tunnifiedZeroHi = 0.73

def intersectionWithNSPoints( pointA, pointB, pointC, pointD ):
	"""
	Returns an NSPoint of the intersection AB with CD.
	Or False if there is no intersection
	"""
	try:
		x1, y1 = pointA.x, pointA.y
		x2, y2 = pointB.x, pointB.y
		x3, y3 = pointC.x, pointC.y
		x4, y4 = pointD.x, pointD.y
		
		try:
			slope12 = ( float(y2) - float(y1) ) / ( float(x2) - float(x1) )
		except:
			# division by zero if vertical
			slope12 = None
			
		try:
			slope34 = ( float(y4) - float(y3) ) / ( float(x4) - float(x3) )
		except:
			# division by zero if vertical
			slope34 = None
		
		if slope12 == slope34:
			# parallel, no intersection
			return None
		elif slope12 is None:
			# first line is vertical
			x = x1
			y = slope34 * ( x - x3 ) + y3
		elif slope34 is None:
			# second line is vertical
			x = x3
			y = slope12 * ( x - x1 ) + y1
		else:
			# both lines have an angle
			x = ( slope12 * x1 - y1 - slope34 * x3 + y3 ) / ( slope12 - slope34 )
			y = slope12 * ( x - x1 ) + y1
			
		intersectionPoint = NSPoint( x, y )
		if bothPointsAreOnSameSideOfOrigin( intersectionPoint, pointB, pointA ) and bothPointsAreOnSameSideOfOrigin( intersectionPoint, pointC, pointD ):
			if pointIsBetweenOtherPoints( intersectionPoint, pointB, pointA ) or pointIsBetweenOtherPoints( intersectionPoint, pointC, pointD ):
				return None
			return intersectionPoint
		else:
			return None
		
	except Exception as e:
		print(e)
		import traceback
		print(traceback.format_exc())
		return None

def bothPointsAreOnSameSideOfOrigin( pointA, pointB, pointOrigin ):
	returnValue = True
	xDiff = (pointA.x-pointOrigin.x) * (pointB.x-pointOrigin.x)
	yDiff = (pointA.y-pointOrigin.y) * (pointB.y-pointOrigin.y)
	if xDiff <= 0.0 and yDiff <= 0.0:
		returnValue = False
	return returnValue

def pointIsBetweenOtherPoints( thisPoint, otherPointA, otherPointB) :
	returnValue = False
	
	xDiffAB = otherPointB.x - otherPointA.x
	yDiffAB = otherPointB.y - otherPointA.y
	xDiffAP = thisPoint.x - otherPointA.x
	yDiffAP = thisPoint.y - otherPointA.y
	xDiffFactor = divideAndTolerateZero( xDiffAP, xDiffAB )
	yDiffFactor = divideAndTolerateZero( yDiffAP, yDiffAB )
	
	if xDiffFactor:
		if 0.0<=xDiffFactor<=1.0:
			returnValue = True
	
	if yDiffFactor:
		if 0.0<=yDiffFactor<=1.0:
			returnValue = True
		
	return returnValue

def divideAndTolerateZero( dividend, divisor ):
	if float(divisor) == 0.0:
		return None
	else:
		return dividend/divisor

def pointDistance( x1, y1, x2, y2 ):
	"""Calculates the distance between P1 and P2."""
	dist = ( ( float(x2) - float(x1) ) ** 2 + ( float(y2) - float(y1) ) **2 ) ** 0.5
	return dist

def bezier( x1, y1,  x2,y2,  x3,y3,  x4,y4,  t ):
	x = x1*(1-t)**3 + x2*3*t*(1-t)**2 + x3*3*t**2*(1-t) + x4*t**3
	y = y1*(1-t)**3 + y2*3*t*(1-t)**2 + y3*3*t**2*(1-t) + y4*t**3
	return x, y

def xyAtPercentageBetweenTwoPoints( firstPoint, secondPoint, percentage ):
	"""
	Returns the x, y for the point at percentage
	(where 100 percent is represented as 1.0)
	between NSPoints firstPoint and secondPoint.
	"""
	x = firstPoint.x + percentage * ( secondPoint.x - firstPoint.x )
	y = firstPoint.y + percentage * ( secondPoint.y - firstPoint.y )
	return x, y

def handlePercentages( segment ):
	"""Calculates the handle distributions and intersection for segment P1, P2, P3, P4."""
	x1, y1 = segment[0]
	x2, y2 = segment[1]
	x3, y3 = segment[2]
	x4, y4 = segment[3]
	
	if [x1, y1] == [x2, y2]:
		# zero handle at beginning of segment
		xInt, yInt = x3, y3
		return tunnifiedZeroLo, tunnifiedZeroHi, xInt, yInt
	elif [x3, y3] == [x4, y4]:
		# zero handle at end of segment
		xInt, yInt = x2, y2
		return tunnifiedZeroHi, tunnifiedZeroLo, xInt, yInt
	else:
		# no zero handle, just bad distribution
		intersectionPoint = intersectionWithNSPoints( NSPoint(x1, y1),  NSPoint(x2, y2),  NSPoint(x3, y3),  NSPoint(x4, y4) )
		if intersectionPoint:
			xInt, yInt = intersectionPoint.x, intersectionPoint.y
			percentageP1P2 = pointDistance( x1, y1, x2, y2 ) / pointDistance( x1, y1, xInt, yInt )
			percentageP3P4 = pointDistance( x4, y4, x3, y3 ) / pointDistance( x4, y4, xInt, yInt )
			tunnifiedPercentage = ( percentageP1P2 + percentageP3P4 ) / 2
			return tunnifiedPercentage, tunnifiedPercentage, xInt, yInt
		else:
			return None

def tunnify( segment ):
	"""
	Calculates the average curvature for Bezier curve segment P1, P2, P3, P4,
	and returns new values for P2, P3.
	"""
	x1, y1 = segment[0]
	x4, y4 = segment[3]
	newHandlePercentages = handlePercentages( segment )
	if newHandlePercentages:
		firstHandlePercentage, secondHandlePercentage, xInt, yInt = newHandlePercentages
		intersectionPoint = NSPoint( xInt, yInt )
		segmentStartPoint = NSPoint( x1, y1 )
		segmentFinalPoint = NSPoint( x4, y4 )
	
		firstHandleX,  firstHandleY  = xyAtPercentageBetweenTwoPoints( segmentStartPoint, intersectionPoint, firstHandlePercentage )
		secondHandleX, secondHandleY = xyAtPercentageBetweenTwoPoints( segmentFinalPoint, intersectionPoint, secondHandlePercentage )
		return firstHandleX, firstHandleY, secondHandleX, secondHandleY
	else:
		return None


Font = Glyphs.font

if len(Font.selectedLayers) > 1:
	selectionCounts = False
elif not Font.selectedLayers[0].selection:
	selectionCounts = False
else:
	selectionCounts = True
	
for selectedLayer in Font.selectedLayers:
	selectedGlyph = selectedLayer.parent
	# selectedGlyph.beginUndo() # undo grouping causes crashes

	for thisPath in selectedLayer.paths:
		numOfNodes = len( thisPath.nodes )
		
		for i,thisNode in enumerate(thisPath.nodes):
			if thisNode.type == GSOFFCURVE and (thisNode.selected or not selectionCounts):
				if thisPath.nodes[i-1].type == GSOFFCURVE:
					segmentNodeIndexes = [ i-2, i-1, i, i+1 ]
				else:
					segmentNodeIndexes = [ i-1, i, i+1, i+2 ]
			
				for x in range(len(segmentNodeIndexes)):
					segmentNodeIndexes[x] = segmentNodeIndexes[x] % numOfNodes
			
				thisSegment = [ (n.x, n.y) for n in [ thisPath.nodes[i] for i in segmentNodeIndexes ] ]
				newSegmentHandles = tunnify( thisSegment )
				if newSegmentHandles:
					x_handle1, y_handle1, x_handle2, y_handle2 = newSegmentHandles
					thisPath.nodes[ segmentNodeIndexes[1] ].x = x_handle1
					thisPath.nodes[ segmentNodeIndexes[1] ].y = y_handle1
					thisPath.nodes[ segmentNodeIndexes[2] ].x = x_handle2
					thisPath.nodes[ segmentNodeIndexes[2] ].y = y_handle2

	# selectedGlyph.endUndo() # undo grouping causes crashes