Esempio n. 1
0
    def test_quad_no_oncurve(self):
        """When passed a contour which has no on-curve points, the
        Cu2QuPointPen will treat it as a special quadratic contour whose
        first point has 'None' coordinates.
        """
        self.maxDiff = None
        pen = DummyPointPen()
        quadpen = Cu2QuPointPen(pen, MAX_ERR)
        quadpen.beginPath()
        quadpen.addPoint((1, 1))
        quadpen.addPoint((2, 2))
        quadpen.addPoint((3, 3))
        quadpen.endPath()

        self.assertEqual(
            str(pen),
            dedent(
                """\
                pen.beginPath()
                pen.addPoint((1, 1), name=None, segmentType=None, smooth=False)
                pen.addPoint((2, 2), name=None, segmentType=None, smooth=False)
                pen.addPoint((3, 3), name=None, segmentType=None, smooth=False)
                pen.endPath()"""
            )
        )
Esempio n. 2
0
    def test_super_bezier_curve(self):
        pen = DummyPointPen()
        quadpen = Cu2QuPointPen(pen, MAX_ERR)
        quadpen.beginPath()
        quadpen.addPoint((0, 0), segmentType="move")
        quadpen.addPoint((1, 1))
        quadpen.addPoint((2, 2))
        quadpen.addPoint((3, 3))
        quadpen.addPoint((4, 4),
                         segmentType="curve",
                         smooth=False,
                         name="up",
                         selected=1)
        quadpen.endPath()

        self.assertEqual(
            str(pen).splitlines(), """\
pen.beginPath()
pen.addPoint((0, 0), name=None, segmentType='move', smooth=False)
pen.addPoint((0.75, 0.75), name=None, segmentType=None, smooth=False)
pen.addPoint((1.625, 1.625), name=None, segmentType=None, smooth=False)
pen.addPoint((2, 2), name=None, segmentType='qcurve', smooth=True)
pen.addPoint((2.375, 2.375), name=None, segmentType=None, smooth=False)
pen.addPoint((3.25, 3.25), name=None, segmentType=None, smooth=False)
pen.addPoint((4, 4), name='up', segmentType='qcurve', selected=1, smooth=False)
pen.endPath()""".splitlines())
Esempio n. 3
0
    def filter(self, glyph):
        if not len(glyph):
            return False

        pen = Cu2QuPointPen(glyph.getPointPen(),
                            self.context.absoluteError,
                            reverse_direction=self.options.reverseDirection,
                            stats=self.context.stats)
        contours = list(glyph)
        glyph.clearContours()
        for contour in contours:
            contour.drawPoints(pen)
        return True
Esempio n. 4
0
    def test__flushContour_restore_starting_point(self):
        pen = DummyPointPen()
        quadpen = Cu2QuPointPen(pen, MAX_ERR)

        # collect the output of _flushContour before it's sent to _drawPoints
        new_segments = []

        def _drawPoints(segments):
            new_segments.extend(segments)
            Cu2QuPointPen._drawPoints(quadpen, segments)

        quadpen._drawPoints = _drawPoints

        # a closed path (ie. no "move" segmentType)
        quadpen._flushContour([
            ("curve", [
                ((2, 2), False, None, {}),
                ((1, 1), False, None, {}),
                ((0, 0), False, None, {}),
            ]),
            ("curve", [
                ((1, 1), False, None, {}),
                ((2, 2), False, None, {}),
                ((3, 3), False, None, {}),
            ]),
        ])

        # the original starting point is restored: the last segment has become
        # the first
        self.assertEqual(new_segments[0][1][-1][0], (3, 3))
        self.assertEqual(new_segments[-1][1][-1][0], (0, 0))

        new_segments = []
        # an open path (ie. starting with "move")
        quadpen._flushContour([
            ("move", [
                ((0, 0), False, None, {}),
            ]),
            ("curve", [
                ((1, 1), False, None, {}),
                ((2, 2), False, None, {}),
                ((3, 3), False, None, {}),
            ]),
        ])

        # the segment order stays the same before and after _flushContour
        self.assertEqual(new_segments[0][1][-1][0], (0, 0))
        self.assertEqual(new_segments[-1][1][-1][0], (3, 3))
Esempio n. 5
0
 def _drawPoints(segments):
     new_segments.extend(segments)
     Cu2QuPointPen._drawPoints(quadpen, segments)
Esempio n. 6
0
 def _drawPoints(segments):
     new_segments.extend(segments)
     Cu2QuPointPen._drawPoints(quadpen, segments)