source: trunk/Lib/robofab/pens/angledMarginPen.py @ 599

from robofab.world import RFont
from fontTools.pens.basePen import BasePen
from robofab.misc.arrayTools import updateBounds, pointInRect, unionRect
from robofab.misc.bezierTools import calcCubicBounds, calcQuadraticBounds
from robofab.pens.filterPen import _estimateCubicCurveLength, _getCubicPoint
import math



__all__ = ["AngledMarginPen", "getAngledMargins", 
        "setAngledLeftMargin", "setAngledRightMargin",
        "centerAngledMargins"]



class AngledMarginPen(BasePen):
        """
                Angled Margin Pen

                Pen to calculate the margins as if the margin lines were slanted
                according to the font.info.italicAngle.

                Notes:
                - this pen works on the on-curve points, and approximates the distance to curves.
                - results will be float.
                - when used in FontLab, the resulting margins may be slightly
                        different from the values originally set, due to rounding errors.
                - similar to what RoboFog used to do.
                - RoboFog had a special attribute for "italicoffset", horizontal
                shift of all glyphs. This is missing in Robofab.
        """
        def __init__(self, glyphSet, width, italicAngle):
                BasePen.__init__(self, glyphSet)
                self.width = width
                self._angle = math.radians(90+italicAngle)
                self.maxSteps = 100
                self.margin = None
                self._left = None
                self._right = None
                self._start = None
                self.currentPt = None
        
        def _getAngled(self, pt):
                r = (g.width + (pt[1] / math.tan(self._angle)))-pt[0]
                l = pt[0]-((pt[1] / math.tan(self._angle)))
                if self._right is None:
                        self._right = r
                else:
                        self._right = min(self._right, r)
                if self._left is None:
                        self._left = l
                else:
                        self._left = min(self._left, l)
                #print pt, l, r
                self.margin = self._left, self._right
                
        def _moveTo(self, pt):
                self._start = self.currentPt = pt

        def _addMoveTo(self):
                if self._start is None:
                        return
                self._start = self.currentPt = None

        def _lineTo(self, pt):
                self._addMoveTo()
                self._getAngled(pt)

        def _curveToOne(self, pt1, pt2, pt3):
                step = 1.0/self.maxSteps
                factors = range(0, self.maxSteps+1)
                for i in factors:
                        pt = _getCubicPoint(i*step, self.currentPt, pt1, pt2, pt3)
                        self._getAngled(pt)
                self.currentPt = pt3
                                        
        def _qCurveToOne(self, bcp, pt):
                self._addMoveTo()
                # add curve tracing magic here.
                self._getAngled(pt)
                self.currentPt = pt3

def getAngledMargins(glyph, font):
        """Get the angled margins for this glyph."""
        pen = AngledMarginPen(font, glyph.width, font.info.italicAngle)
        glyph.draw(pen)
        return pen.margin
        
def setAngledLeftMargin(glyph, font, value):
        """Set the left angled margin to value, adjusted for font.info.italicAngle."""
        pen = AngledMarginPen(font, glyph.width, font.info.italicAngle)
        g.draw(pen)
        isLeft, isRight = pen.margin
        glyph.leftMargin += value-isLeft
        
def setAngledRightMargin(glyph, font, value):
        """Set the right angled margin to value, adjusted for font.info.italicAngle."""
        pen = AngledMarginPen(font, glyph.width, font.info.italicAngle)
        g.draw(pen)
        isLeft, isRight = pen.margin
        glyph.rightMargin += value-isRight

def centerAngledMargins(glyph, font):
        """Center the glyph on angled margins."""
        pen = AngledMarginPen(font, glyph.width, font.info.italicAngle)
        g.draw(pen)
        isLeft, isRight = pen.margin
        setAngledLeftMargin(glyph, font, (isLeft+isRight)*.5)
        setAngledRightMargin(glyph, font, (isLeft+isRight)*.5)
        
def guessItalicOffset(glyph, font):
        """Guess the italic offset based on the margins of a symetric glyph.
                For instance H or I.
        """
        l, r = getAngledMargins(glyph, font)
        return l - (l+r)*.5


if __name__ == "__main__":
        
        # example for FontLab, with a glyph open.
        from robofab.world import CurrentFont, CurrentGlyph
        g = CurrentGlyph()
        f = CurrentFont()

        print "margins!", getAngledMargins(g, f)
        # set the angled margin to a value
        m = 50
        setAngledLeftMargin(g, f, m)
        setAngledRightMargin(g, f, m)
        g.update()