Exemplo n.º 1
0
    def draw(self, canvas):
        edgepath = pyx.metapost.path.path([
            beginknot(*self.start_point), tensioncurve(),
            smoothknot(*self.mid_point), tensioncurve(),
            endknot(*self.end_point)
        ])

        canvas.stroke(edgepath,
                      [pyx.style.linewidth(self.thickness), pyx.color.rgb(*self.colour), pyx.color.transparency(
                          1-self.alpha)])
Exemplo n.º 2
0
    def path_ERCRs(cls, ta=None, **kwargs):
        #M 47.3414,204.715 C 52.5904,202.267 69.9633,198.714 69.9633,203.133 69.9633,204.824 68.759159,205.69577 67.984038,205.24378 66.963114,204.64846 66.179134,203.58453 66.179134,201.07007

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860374)
        #c1 = P(7.95069, 2.10911)
        #z1 = P(7.95069, 0.55601)
        #c2 = P(7.95069, -0.0383091)
        #c3 = P(7.52748, -0.344701)
        #z2 = P(7.25506, -0.185845)
        #c4 = P(6.89625, 0.0233861)
        #c5 = P(6.62071, 0.397315)
        z3 = P(6.62071, 1.28105)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860374)
        #z1 = z0 + P(7.95069, 0.55601)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-0.695631, -0.741854)
        #c3 = z2 + P(0.272424, -0.158856)
        #c4 = z2 + P(-0.358814, 0.209231)
        #z3 = z2 + P(-0.634351, 1.46689)
        #c5 = z3 + P(0, -0.883732)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03558, 25)
        z1 = z0 + PP(7.97011, 4)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(1.01698, -133)
        #z2 = z3 - PP(1.59818, ta + 383)
        c3 = z2 + PP(0.315357, -30)
        #c4 = z2 + PP(0.415361, 149)
        #z3 = z2 + PP(1.59818, 113)
        #c5 = z3 + PP(0.883732, -90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 3
0
    def path_ERCRner(cls, ta=None, **kwargs):
        #M 164.6,165.754 C 169.849,163.306 187.222,159.753 187.222,164.172 187.222,165.862 185.90959,166.54157 185.24194,166.556 183.8302,166.58652 184.19678,164.17618 185.04919,162.32418

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860374)
        #c1 = P(7.95073, 2.10911)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0379577)
        #c3 = P(7.48947, -0.276799)
        #z2 = P(7.25481, -0.281871)
        #c4 = P(6.75864, -0.292597)
        #c5 = P(6.88748, 0.55454)
        z3 = P(7.18707, 1.20544)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860374)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.593967)
        #z2 = z1 + P(-0.695912, -0.83788)
        #c3 = z2 + P(0.234652, 0.00507157)
        #c4 = z2 + P(-0.49617, -0.0107266)
        #z3 = z2 + P(-0.0677439, 1.48731)
        #c5 = z3 + P(-0.299588, -0.650904)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03558, 25)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.593967, -90)
        #z2 = z1 + PP(1.08919, -129)
        z2 = z3 - PP(1.48886, ta + 386)
        c3 = z2 + PP(0.234707, 1)
        #c4 = z2 + PP(0.496286, -178)
        #z3 = z2 + PP(1.48886, 92)
        #c5 = z3 + PP(0.716539, -114)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 4
0
    def path_ERCRne(cls, ta=None, **kwargs):
        #M 47.3414,165.754 C 52.5904,163.306 69.9633,159.753 69.9633,164.172 69.9633,165.862 66.767337,166.75662 66.229037,166.33662 65.119337,165.43762 66.91415,163.90256 68.6986,162.599

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860374)
        #c1 = P(7.95069, 2.10911)
        #z1 = P(7.95069, 0.55601)
        #c2 = P(7.95069, -0.0379577)
        #c3 = P(6.82744, -0.352381)
        #z2 = P(6.63825, -0.204768)
        #c4 = P(6.24823, 0.111195)
        #c5 = P(6.87904, 0.650707)
        z3 = P(7.5062, 1.10886)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860374)
        #z1 = z0 + P(7.95069, 0.55601)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.593967)
        #z2 = z1 + P(-1.31244, -0.760777)
        #c3 = z2 + P(0.189191, -0.147613)
        #c4 = z2 + P(-0.390015, 0.315962)
        #z3 = z2 + P(0.867952, 1.31362)
        #c5 = z3 + P(-0.627163, -0.458149)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03558, 25)
        z1 = z0 + PP(7.97011, 4)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.593967, -90)
        #z2 = z1 + PP(1.517, -149)
        z2 = z3 - PP(1.57447, ta + 379)
        c3 = z2 + PP(0.239964, -37)
        #c4 = z2 + PP(0.50194, 140)
        #z3 = z2 + PP(1.57447, 56)
        #c5 = z3 + PP(0.776681, -143)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 5
0
    def path_ERCR(cls, ta=None, **kwargs):
        #M 51.215,0 C 56.44,-2.5484 73.9217,-6.02324 73.9217,-1.58781 73.9217,0.109255 71.002938,1.1833198 70.46835,0.75406082 69.350805,-0.1432963 71.271496,-1.3295413 72.6523,-3.16655

        #z0 = P(0, 0)
        #c0 = P(1.83638, 0.89566)
        #c1 = P(7.98049, 2.11693)
        #z1 = P(7.98049, 0.558052)
        #c2 = P(7.98049, -0.0383987)
        #c3 = P(6.95467, -0.415889)
        #z2 = P(6.76678, -0.265022)
        #c4 = P(6.37401, 0.0503629)
        #c5 = P(7.04905, 0.46728)
        z3 = P(7.53435, 1.11292)

        #z0 = P(0, 0)
        #c0 = z0 + P(1.83638, 0.89566)
        #z1 = z0 + P(7.98049, 0.558052)
        #c1 = z1 + P(0, 1.55888)
        #c2 = z1 + P(0, -0.59645)
        #z2 = z1 + P(-1.21371, -0.823074)
        #c3 = z2 + P(0.187886, -0.150867)
        #c4 = z2 + P(-0.392772, 0.315385)
        #z3 = z2 + P(0.767571, 1.37794)
        #c5 = z3 + P(-0.485297, -0.645635)

        z0 = P(0, 0)
        c0 = z0 + PP(2.04316, 25)
        z1 = z0 + PP(7.99998, 4)
        c1 = z1 + PP(1.55888, 90)
        c2 = z1 + PP(0.59645, -90)
        z2 = z1 + PP(1.46648, -145)
        #z2 = z3 - PP(1.5773, ta + 366)
        c3 = z2 + PP(0.240961, -38)
        c4 = z2 + PP(0.503724, 141)
        #z3 = z2 + PP(1.5773, 60)
        c5 = z3 + PP(0.807687, -126)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 6
0
    def path_HEF(self, ta=None, **kwwargs):
        #M -52.61608,683.83749 C -55.179261,684.72029 -56.033878,681.25612 -54.427995,681.16729 -48.023468,680.81307 -4.1711966,680.69047 -4.1711966,680.69047
        z0 = P(0, -0)
        c0 = P(-0.904233, -0.311432)
        c1 = P(-1.20572, 0.91065)
        z1 = P(-0.639203, 0.941987)
        c2 = P(1.62017, 1.06695)
        c3 = P(17.0903, 1.1102)
        z2 = P(17.0903, 1.1102)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)
        ])
Exemplo n.º 7
0
    def path_ERCRswr(cls, ta=None, **kwargs):
        #M 107.343,351.419 C 112.592,348.972 129.965,345.419 129.965,349.837 129.965,351.528 129.22019,352.25696 128.49392,352.14464 128.00997,352.0698 127.311,349.50717 127.06208,347.86126

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860022)
        #c1 = P(7.95073, 2.10876)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(7.68895, -0.294509)
        #z2 = P(7.4337, -0.255033)
        #c4 = P(7.26361, -0.22873)
        #c5 = P(7.01795, 0.671932)
        z3 = P(6.93047, 1.2504)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860022)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.55275)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-0.517026, -0.811043)
        #c3 = z2 + P(0.255255, -0.039476)
        #c4 = z2 + P(-0.170089, 0.0263033)
        #z3 = z2 + P(-0.503234, 1.50544)
        #c5 = z3 + P(0.0874854, -0.578471)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03543, 24)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.55275, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(0.961824, -122)
        #z2 = z3 - PP(1.58732, ta + 369)
        c3 = z2 + PP(0.258289, -8)
        #c4 = z2 + PP(0.172111, 171)
        #z3 = z2 + PP(1.58732, 108)
        #c5 = z3 + PP(0.585049, -81)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 8
0
    def path_ERCRsel(cls, ta=None, **kwargs):
        #M 163.762,280.93 C 169.011,278.483 186.384,274.93 186.384,279.349 186.384,281.039 185.74124,281.93836 184.99558,281.69422 184.00882,281.37114 183.24576,279.34541 183.21648,277.34003

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860022)
        #c1 = P(7.95073, 2.10876)
        #z1 = P(7.95073, 0.555658)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(7.72482, -0.354398)
        #z2 = P(7.46275, -0.268593)
        #c4 = P(7.11594, -0.155043)
        #c5 = P(6.84776, 0.55692)
        z3 = P(6.83747, 1.26173) + P(0, -0.2)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860022)
        #z1 = z0 + P(7.95073, 0.555658)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.593967)
        #z2 = z1 + P(-0.487974, -0.824251)
        #c3 = z2 + P(0.26207, -0.0858054)
        #c4 = z2 + P(-0.346807, 0.11355)
        #z3 = z2 + P(-0.625282, 1.53032)
        #c5 = z3 + P(0.0102907, -0.704811)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03543, 24)
        z1 = z0 + PP(7.97012, 3)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.593967, -90)
        z2 = z1 + PP(0.957866, -120)
        #z2 = z3 - PP(1.65314, ta + 381)
        c3 = z2 + PP(0.275759, -18)
        #c4 = z2 + PP(0.364922, 161)
        #z3 = z2 + PP(1.65314, 112)
        #c5 = z3 + PP(0.704886, -89)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 9
0
    def path_SCL(cls, ta=None, **kwargs):
        #M 47.3414,53.0079 C 47.5141,54.0979 47.6399,61.4316 47.1454,64.2361 46.9959,65.2998 49.262023,64.672557 49.614023,63.016657 49.944223,61.586657 48.0207,60.5387 47.5185,60.2717

        #z0 = P(0, -0)
        #c0 = P(0.0609247, -0.384528)
        #c1 = P(0.105304, -2.97169)
        #z1 = P(-0.0691444, -3.96106)
        #c2 = P(-0.121885, -4.33631)
        #c3 = P(0.677553, -4.11503)
        #z2 = P(0.801731, -3.53087)
        #c4 = P(0.918218, -3.02639)
        #c5 = P(0.239642, -2.6567)
        z3 = P(0.0624769, -2.56251)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.0609247, -0.384528)
        #z1 = z0 + P(-0.0691444, -3.96106)
        #c1 = z1 + P(0.174449, 0.989365)
        #c2 = z1 + P(-0.0527403, -0.37525)
        #z2 = z1 + P(0.870875, 0.430192)
        #c3 = z2 + P(-0.124178, -0.584165)
        #c4 = z2 + P(0.116487, 0.504472)
        #z3 = z2 + P(-0.739254, 0.96836)
        #c5 = z3 + P(0.177165, -0.0941917)

        z0 = P(0, -0)
        c0 = z0 + PP(0.389324, -80)
        z1 = z0 + PP(3.96166, -91)
        c1 = z1 + PP(1.00463, 80)
        c2 = z1 + PP(0.378938, -98)
        z2 = z1 + PP(0.971334, 26)
        #z2 = z3 - PP(1.21828, ta + 334)
        c3 = z2 + PP(0.597217, -102)
        c4 = z2 + PP(0.517747, 76)
        z3 = z2 + PP(1.21828, 127)
        c5 = z3 + PP(0.200648, -27)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 10
0
    def path_elUWL(cls, ta=None, **kwargs):
        #M 379.57125,79.080276 C 376.87521,81.066608 373.83181,83.185161 375.08771,85.166596 375.91791,86.476394 377.80173,86.700437 380.38857,85.44541

        z0 = P(0, -0)
        c0 = P(-0.951103, -0.700734)
        c1 = P(-2.02475, -1.44811)
        z1 = P(-1.58169, -2.14712)
        c2 = P(-1.28882, -2.60919)
        c3 = P(-0.624247, -2.68822)
        z2 = P(0.288332, -2.24548)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)])
Exemplo n.º 11
0
    def path_eUWL(cls, ta=None, **kwargs):
        #M 377.45,173.055 C 374.94127,173.055 372.49656,174.32588 372.49656,178.11188 372.54756,181.01388 376.56456,182.10388 378.33056,181.08488

        z0 = P(0, -0)
        c0 = P(-0.885024, -0)
        c1 = P(-1.74746, -0.448338)
        z1 = P(-1.74746, -1.78395)
        c2 = P(-1.72947, -2.80772)
        c3 = P(-0.312364, -3.19224)
        z2 = P(0.310642, -2.83276)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)])
Exemplo n.º 12
0
    def path_HSELF(self, ta=None, **kwwargs):
        #M 238.79262,800.29103 C 236.23592,797.79648 232.92187,795.96335 231.76951,799.69051 227.36758,813.92802 257.21226,836.26674 274.33137,831.15964
        z0 = P(0, -0)
        c0 = P(-0.901947, 0.880022)
        c1 = P(-2.07107, 1.52671)
        z1 = P(-2.4776, 0.21185)
        c2 = P(-4.0305, -4.81083)
        c3 = P(6.49804, -12.6914)
        z2 = P(12.5373, -10.8898)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)
        ])
Exemplo n.º 13
0
    def path_CLS(cls, ta=None, **kwawrgs):
        #M 43.795945,140.09579 C 45.470302,140.6469 46.714517,138.11422 45.755053,136.83728 44.456076,135.10849 43.643102,135.9591 43.755612,139.06533 43.802345,140.35556 43.680184,145.16142 43.660745,146.44297

        #z0 = P(0, -0)
        #c0 = P(0.590676, -0.194419)
        #c1 = P(1.02961, 0.699054)
        #z1 = P(0.69113, 1.14953)
        #c2 = P(0.23288, 1.75941)
        #c3 = P(-0.0539196, 1.45933)
        #z2 = P(-0.0142286, 0.363523)
        #c4 = P(0.00225778, -0.0916411)
        #c5 = P(-0.0408379, -1.78704)
        z3 = P(-0.0476956, -2.23914)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.590676, -0.194419)
        #z1 = z0 + P(0.69113, 1.14953)
        #c1 = z1 + P(0.338478, -0.450476)
        #c2 = z1 + P(-0.45825, 0.609879)
        #z2 = z1 + P(-0.705358, -0.786007)
        #c3 = z2 + P(-0.039691, 1.09581)
        #c4 = z2 + P(0.0164864, -0.455164)
        #z3 = z2 + P(-0.033467, -2.60267)
        #c5 = z3 + P(0.00685765, 0.452102)

        z0 = P(0, -0)
        c0 = z0 + PP(0.62185, -18)
        z1 = z0 + PP(1.3413, 58)
        c1 = z1 + PP(0.563468, -53)
        c2 = z1 + PP(0.762853, 126)
        z2 = z1 + PP(1.0561, -131)
        #z2 = z3 - PP(2.60288, ta + 1)
        c3 = z2 + PP(1.09653, 92)
        c4 = z2 + PP(0.455463, -87)
        z3 = z2 + PP(2.60288, -90)
        c5 = z3 + PP(0.452154, 89)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 14
0
    def path_CRS(cls, ta=None, **kwargs):
        #M 206.577,112.48 C 203.708,113.412 204.09,109.93739 205.314,109.44339 205.771,109.26839 206.674,109.37039 206.637,110.44039 206.7,114.05039 206.637,117.065 206.637,120.928

        #z0 = P(0, -0)
        #c0 = P(-1.01212, -0.328789)
        #c1 = P(-0.877358, 0.896976)
        #z1 = P(-0.445558, 1.07125)
        #c2 = P(-0.284339, 1.13298)
        #c3 = P(0.0342194, 1.097)
        #z2 = P(0.0211667, 0.719529)
        #c4 = P(0.0433917, -0.553999)
        #c5 = P(0.0211667, -1.61749)
        z3 = P(0.0211667, -2.98027)

        #z0 = P(0, -0)
        #c0 = z0 + P(-1.01212, -0.328789)
        #z1 = z0 + P(-0.445558, 1.07125)
        #c1 = z1 + P(-0.4318, -0.174272)
        #c2 = z1 + P(0.161219, 0.0617361)
        #z2 = z1 + P(0.466725, -0.351719)
        #c3 = z2 + P(0.0130528, 0.377472)
        #c4 = z2 + P(0.022225, -1.27353)
        #z3 = z2 + P(0, -3.6998)
        #c5 = z3 + P(0, 1.36278)

        z0 = P(0, -0)
        c0 = z0 + PP(1.06418, -162)
        z1 = z0 + PP(1.16021, 112)
        c1 = z1 + PP(0.465642, -158)
        c2 = z1 + PP(0.172636, 20)
        z2 = z1 + PP(0.584413, -37)
        #z2 = z3 - PP(3.6998, ta + 0)
        c3 = z2 + PP(0.377698, 88)
        c4 = z2 + PP(1.27372, -89)
        z3 = z2 + PP(3.6998, -90)
        c5 = z3 + PP(1.36278, 90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 15
0
    def path_ERCRsl(cls, ta=None, **kwargs):
        #M 111.221,204.715 C 116.47,202.267 133.843,198.714 133.843,203.133 133.843,204.824 132.34197,205.88965 131.69941,205.57284 130.41826,204.9412 130.27009,203.11867 131.35335,201.22161

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860374)
        #c1 = P(7.95073, 2.10911)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(7.42317, -0.412842)
        #z2 = P(7.19734, -0.301496)
        #c4 = P(6.74707, -0.0795002)
        #c5 = P(6.69499, 0.561046)
        z3 = P(7.07571, 1.22779)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860374)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-0.753386, -0.857506)
        #c3 = z2 + P(0.225834, -0.111346)
        #c4 = z2 + P(-0.450273, 0.221996)
        #z3 = z2 + P(-0.121626, 1.52928)
        #c5 = z3 + P(-0.380722, -0.66674)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03558, 25)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(1.14145, -131)
        #z2 = z3 - PP(1.53411, ta + 393)
        c3 = z2 + PP(0.251791, -26)
        c4 = z2 + PP(0.502024, 153)
        #z3 = z2 + PP(1.53411, 94)
        c5 = z3 + PP(0.767784, -119)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 16
0
    def path_SELEF(self, ta=None, **kwwargs):
        #M 192.72117,858.05473 C 192.55657,864.26793 197.90319,875.10232 205.23117,875.83208 208.82987,876.19045 256.25877,876.16131 256.25877,876.16131
        z0 = P(0, -0)
        c0 = P(-0.0580672, -2.19188)
        c1 = P(1.8281, -6.01401)
        z1 = P(4.41325, -6.27145)
        c2 = P(5.68279, -6.39788)
        c3 = P(22.4147, -6.3876)
        z2 = P(22.4147, -6.3876)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)
        ])
Exemplo n.º 17
0
    def path_SCLswl(cls, ta=None, **kwargs):
        #M 384.48,111.292 C 384.634,112.385 384.779,119.715 384.284,122.52 384.116,123.581 386.82658,123.22934 387.289,121.601 388.0727,118.84135 386.01363,119.89367 384.46552,120.57855

        #z0 = P(0, -0)
        #c0 = P(0.0543278, -0.385586)
        #c1 = P(0.105481, -2.97145)
        #z1 = P(-0.0691444, -3.96099)
        #c2 = P(-0.128411, -4.33529)
        #c3 = P(0.827821, -4.21123)
        #z2 = P(0.990953, -3.63679)
        #c4 = P(1.26742, -2.66324)
        #c5 = P(0.541031, -3.03448)
        z3 = P(-0.00510822, -3.27609)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.0543278, -0.385586)
        #z1 = z0 + P(-0.0691444, -3.96099)
        #c1 = z1 + P(0.174625, 0.989542)
        #c2 = z1 + P(-0.0592667, -0.374297)
        #z2 = z1 + P(1.0601, 0.324203)
        #c3 = z2 + P(-0.163132, -0.574442)
        #c4 = z2 + P(0.276472, 0.973543)
        #z3 = z2 + P(-0.996061, 0.360698)
        #c5 = z3 + P(0.546139, 0.24161)

        z0 = P(0, -0)
        c0 = z0 + PP(0.389395, -81)
        z1 = z0 + PP(3.96159, -91)
        c1 = z1 + PP(1.00483, 79)
        c2 = z1 + PP(0.37896, -98)
        #z2 = z1 + PP(1.10856, 17)
        z2 = z3 - PP(1.05936, ta + 317)
        c3 = z2 + PP(0.597156, -105)
        #c4 = z2 + PP(1.01204, 74)
        #z3 = z2 + PP(1.05936, 160)
        #c5 = z3 + PP(0.597196, 23)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 18
0
    def path_ERCRsw(cls, ta=None, **kwargs):
        #M 47.3414,351.419 C 52.5904,348.972 69.9633,345.419 69.9633,349.837 69.9633,351.528 68.754326,352.76467 67.989201,352.18332 66.852047,351.31931 67.00385,349.80907 67.675087,347.96499

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860022)
        #c1 = P(7.95069, 2.10876)
        #z1 = P(7.95069, 0.55601)
        #c2 = P(7.95069, -0.0383091)
        #c3 = P(7.52578, -0.472949)
        #z2 = P(7.25687, -0.268628)
        #c4 = P(6.85721, 0.035037)
        #c5 = P(6.91056, 0.565826)
        z3 = P(7.14648, 1.21395)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860022)
        #z1 = z0 + P(7.95069, 0.55601)
        #c1 = z1 + P(0, 1.55275)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-0.693817, -0.824637)
        #c3 = z2 + P(0.268911, -0.204321)
        #c4 = z2 + P(-0.399664, 0.303665)
        #z3 = z2 + P(-0.110398, 1.48257)
        #c5 = z3 + P(-0.235913, -0.64812)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03543, 24)
        z1 = z0 + PP(7.97011, 4)
        c1 = z1 + PP(1.55275, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(1.07769, -130)
        #z2 = z3 - PP(1.48668, ta + 384)
        c3 = z2 + PP(0.337728, -37)
        #c4 = z2 + PP(0.50194, 142)
        #z3 = z2 + PP(1.48668, 94)
        #c5 = z3 + PP(0.689721, -110)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 19
0
    def path_ERCRer(cls, ta=None, **kwargs):
        #M 180.77,112.215 C 186.019,109.768 203.392,106.215 203.392,110.633 203.392,112.324 200.525,113.438 199.987,113.018 199.20606,112.39322 200.12387,110.20003 202.127,109.061

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860022)
        #c1 = P(7.95073, 2.10876)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(6.94309, -0.429835)
        #z2 = P(6.754, -0.282222)
        #c4 = P(6.47954, -0.0626372)
        #c5 = P(6.80211, 0.708181)
        z3 = P(7.50613, 1.1085)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860022)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.55275)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-1.19672, -0.838232)
        #c3 = z2 + P(0.189085, -0.147613)
        #c4 = z2 + P(-0.274469, 0.219585)
        #z3 = z2 + P(0.752124, 1.39073)
        #c5 = z3 + P(-0.70402, -0.400323)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03543, 24)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.55275, 90)
        c2 = z1 + PP(0.594319, -90)
        #z2 = z1 + PP(1.46109, -144)
        z2 = z3 - PP(1.58108, ta + 391)
        c3 = z2 + PP(0.239881, -37)
        #c4 = z2 + PP(0.351498, 141)
        #z3 = z2 + PP(1.58108, 61)
        #c5 = z3 + PP(0.809878, -150)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 20
0
    def path_ERCRswl(cls, ta=None, **kwargs):
        #M161.322 351.419C166.571 348.972 183.944 345.419 183.944 349.837C183.944 351.528 181.077 352.642 180.539 352.222C179.429 351.323 181.334 350.117 182.679 348.265

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860022)
        #c1 = P(7.95073, 2.10876)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(6.94309, -0.429835)
        #z2 = P(6.754, -0.282222)
        #c4 = P(6.36388, 0.0337401)
        #c5 = P(7.03342, 0.457601)
        z3 = P(7.50613, 1.1085)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860022)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.55275)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-1.19672, -0.838232)
        #c3 = z2 + P(0.189085, -0.147613)
        #c4 = z2 + P(-0.39012, 0.315962)
        #z3 = z2 + P(0.752124, 1.39073)
        #c5 = z3 + P(-0.472714, -0.650904)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03543, 24)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.55275, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(1.46109, -144)
        #z2 = z3 - PP(1.58108, ta + 366)
        c3 = z2 + PP(0.239881, -37)
        #c4 = z2 + PP(0.502022, 140)
        #z3 = z2 + PP(1.58108, 61)
        #c5 = z3 + PP(0.804446, -125)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 21
0
    def path_ERCRsr(cls, ta=None, **kwargs):
        #M 175.101,204.715 C 180.35,202.267 197.723,198.714 197.723,203.133 197.723,204.824 197.13956,205.25972 196.56659,205.13409 195.17135,204.82818 194.40217,202.86664 193.33263,201.04173

        #z0 = P(0, -0)
        #c0 = P(1.84481, 0.860374)
        #c1 = P(7.95073, 2.10911)
        #z1 = P(7.95073, 0.55601)
        #c2 = P(7.95073, -0.0383091)
        #c3 = P(7.74567, -0.191447)
        #z2 = P(7.54429, -0.147293)
        #c4 = P(7.05392, -0.0397782)
        #c5 = P(6.78359, 0.649624)
        z3 = P(6.40769, 1.29101)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.84481, 0.860374)
        #z1 = z0 + P(7.95073, 0.55601)
        #c1 = z1 + P(0, 1.5531)
        #c2 = z1 + P(0, -0.594319)
        #z2 = z1 + P(-0.406432, -0.703303)
        #c3 = z2 + P(0.201376, -0.0441539)
        #c4 = z2 + P(-0.490371, 0.107515)
        #z3 = z2 + P(-1.13661, 1.4383)
        #c5 = z3 + P(0.3759, -0.641383)

        z0 = P(0, -0)
        c0 = z0 + PP(2.03558, 25)
        z1 = z0 + PP(7.97014, 4)
        c1 = z1 + PP(1.5531, 90)
        c2 = z1 + PP(0.594319, -90)
        z2 = z1 + PP(0.812294, -120)
        #z2 = z3 - PP(1.83319, ta + 367)
        c3 = z2 + PP(0.20616, -12)
        c4 = z2 + PP(0.502019, 167)
        #z3 = z2 + PP(1.83319, 128)
        c5 = z3 + PP(0.74342, -59)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 22
0
    def path_HSR(cls, ta=None, **kwargs):
        #M 134.74093,780.4697 C 133.02975,777.58594 134.39659,774.0219 136.14803,774.37228 143.65678,775.87442 143.65958,794.88669 136.22987,799.8803

        z0 = P(0, -0)
        c0 = P(-0.603666, 1.01733)
        c1 = P(-0.121475, 2.27464)
        z1 = P(0.496394, 2.15103)
        c2 = P(3.14531, 1.62111)
        c3 = P(3.1463, -5.08599)
        z2 = P(0.525265, -6.84763)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            endknot(*z2)])
Exemplo n.º 23
0
    def path_SWRCL(cls, ta=None, **kwargs):
        #M 527.053,93.507 C 527.053,105.509 515.01232,131.43645 505.63778,132.53905 502.8243,132.86997 505.0678,134.75646 505.89569,135.16677 507.13105,135.77901 507.89996,133.50279 507.61351,132.07056

        #z0 = P(0, -0)
        #c0 = P(0, -4.23404)
        #c1 = P(-4.24768, -13.3807)
        #z1 = P(-7.55481, -13.7696)
        #c2 = P(-8.54735, -13.8864)
        #c3 = P(-7.75589, -14.5519)
        #z2 = P(-7.46383, -14.6966)
        #c4 = P(-7.02802, -14.9126)
        #c5 = P(-6.75677, -14.1096)
        z3 = P(-6.85782, -13.6044)

        #z0 = P(0, -0)
        #c0 = z0 + P(0, -4.23404)
        #z1 = z0 + P(-7.55481, -13.7696)
        #c1 = z1 + P(3.30713, 0.388973)
        #c2 = z1 + P(-0.992533, -0.116741)
        #z2 = z1 + P(0.0909849, -0.927001)
        #c3 = z2 + P(-0.292061, 0.144748)
        #c4 = z2 + P(0.435808, -0.215985)
        #z3 = z2 + P(0.606009, 1.09227)
        #c5 = z3 + P(0.101053, -0.505259)

        z0 = P(0, -0)
        c0 = z0 + PP(4.23404, -90)
        z1 = z0 + PP(15.706, -118)
        c1 = z1 + PP(3.32993, 6)
        c2 = z1 + PP(0.999375, -173)
        z2 = z1 + PP(0.931456, -84)
        #z2 = z3 - PP(1.24912, ta + 318)
        c3 = z2 + PP(0.325963, 153)
        c4 = z2 + PP(0.486392, -26)
        z3 = z2 + PP(1.24912, 60)
        c5 = z3 + PP(0.515265, -78)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 24
0
    def path_NELCR(cls, ta=None, **kwargs):
        #M 47.3414,58.6772 C 55.8544,52.9351 77.848432,37.678531 79.127996,27.836616 79.555908,24.545281 81.78587,27.125115 81.770975,28.007829 81.751316,29.172871 80.855838,30.104291 78.508254,30.256143

        #z0 = P(0, -0)
        #c0 = P(3.0032, 2.02569)
        #c1 = P(10.7622, 7.40786)
        #z1 = P(11.2136, 10.8799)
        #c2 = P(11.3646, 12.041)
        #c3 = P(12.1512, 11.1309)
        #z2 = P(12.146, 10.8195)
        #c4 = P(12.1391, 10.4085)
        #c5 = P(11.8231, 10.0799)
        z3 = P(10.995, 10.0263)

        #z0 = P(0, -0)
        #c0 = z0 + P(3.0032, 2.02569)
        #z1 = z0 + P(11.2136, 10.8799)
        #c1 = z1 + P(-0.451402, -3.47201)
        #c2 = z1 + P(0.150958, 1.16111)
        #z2 = z1 + P(0.932384, -0.0604001)
        #c3 = z2 + P(0.00525463, 0.311402)
        #c4 = z2 + P(-0.00693526, -0.411001)
        #z3 = z2 + P(-1.15102, -0.793155)
        #c5 = z3 + P(0.828175, 0.05357)

        z0 = P(0, -0)
        c0 = z0 + PP(3.62251, 34)
        z1 = z0 + PP(15.6242, 44)
        c1 = z1 + PP(3.50123, -97)
        c2 = z1 + PP(1.17088, 82)
        z2 = z1 + PP(0.934339, -3)
        #z2 = z3 - PP(1.39783, ta + 32)
        c3 = z2 + PP(0.311446, 89)
        c4 = z2 + PP(0.411059, -90)
        z3 = z2 + PP(1.39783, -145)
        c5 = z3 + PP(0.829906, 3)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 25
0
    def path_NELCRner(cls, ta=None, **kwargs):
        #M 116.237,100.939 C 124.75,95.1967 146.886,80.0238 148.096,70.173 148.558,66.8863 150.38143,70.327867 150.36643,71.210567 149.93835,73.232021 147.0119,73.013988 147.94448,70.486811

        #z0 = P(0, -0)
        #c0 = P(3.0032, 2.02576)
        #c1 = P(10.8123, 7.37842)
        #z1 = P(11.2391, 10.8536)
        #c2 = P(11.4021, 12.013)
        #c3 = P(12.0454, 10.7989)
        #z2 = P(12.0401, 10.4875)
        #c4 = P(11.8891, 9.77441)
        #c5 = P(10.8567, 9.85132)
        z3 = P(11.1857, 10.7429)

        #z0 = P(0, -0)
        #c0 = z0 + P(3.0032, 2.02576)
        #z1 = z0 + P(11.2391, 10.8536)
        #c1 = z1 + P(-0.426861, -3.47514)
        #c2 = z1 + P(0.162983, 1.15947)
        #z2 = z1 + P(0.800957, -0.366031)
        #c3 = z2 + P(0.00529167, 0.311397)
        #c4 = z2 + P(-0.151017, -0.713124)
        #z3 = z2 + P(-0.85441, 0.255325)
        #c5 = z3 + P(-0.328994, -0.891532)

        z0 = P(0, -0)
        c0 = z0 + PP(3.62255, 34)
        z1 = z0 + PP(15.6243, 44)
        c1 = z1 + PP(3.50126, -97)
        c2 = z1 + PP(1.17087, 81)
        #z2 = z1 + PP(0.880631, -24)
        z2 = z3 - PP(0.891744, ta + 453)
        c3 = z2 + PP(0.311442, 89)
        #c4 = z2 + PP(0.728939, -101)
        #z3 = z2 + PP(0.891744, 163)
        #c5 = z3 + PP(0.950298, -110)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta)])
Exemplo n.º 26
0
    def path_CLNEL_tan(cls, ta=None, **kwargs):
        #M197.057 85.1045C197.222 83.2189 195.408 83.4309 194.326 84.217C193.67 84.7112 193.127 87.6204 194.754 86.6431C203.646 81.5088 226.558 65.0619 226.558 54.8389

        #z0 = P(0, -0)
        #c0 = P(0.0582083, 0.665198)
        #c1 = P(-0.581731, 0.590409)
        #z1 = P(-0.963436, 0.31309)
        #c2 = P(-1.19486, 0.138747)
        #c3 = P(-1.38642, -0.887554)
        #z2 = P(-0.812447, -0.542784)
        #c4 = P(2.32445, 1.26848)
        #c5 = P(10.4073, 7.07058)
        z3 = P(10.4073, 10.677)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.0582083, 0.665198)
        #z1 = z0 + P(-0.963436, 0.31309)
        #c1 = z1 + P(0.381706, 0.277319)
        #c2 = z1 + P(-0.231422, -0.174343)
        #z2 = z1 + P(0.150989, -0.855874)
        #c3 = z2 + P(-0.573969, -0.34477)
        #c4 = z2 + P(3.1369, 1.81127)
        #z3 = z2 + P(11.2197, 11.2198)
        #c5 = z3 + P(0, -3.60645)

        z0 = P(0, -0)
        c0 = z0 + PP(0.66774, 84)
        z1 = z0 + PP(1.01303, 161)
        c1 = z1 + PP(0.47181, 35)
        c2 = z1 + PP(0.289744, -143)
        z2 = z1 + PP(0.86909, -79)
        #z2 = z3 - PP(15.8672, ta + 315)
        c3 = z2 + PP(0.669557, -149)
        #c4 = z2 + PP(3.62227, 30)
        #z3 = z2 + PP(15.8672, 45)
        #c5 = z3 + PP(3.60645, -90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            #controlcurve(c4, c5),
            curve(),
            endknot(*z3, angle=ta+180)])
Exemplo n.º 27
0
    def path_CLNEL(cls, ta=None, **kwargs):
        #M 50.0595,56.971031 C 50.203034,55.083653 48.389478,55.317438 47.317507,56.117161 46.659329,56.608182 46.109285,59.51212 47.741261,58.543913 56.572561,53.304541 79.4118,36.8298 79.4118,26.6068

        #z0 = P(0, -0)
        #c0 = P(0.0506356, 0.665825)
        #c1 = P(-0.589147, 0.583351)
        #z1 = P(-0.967314, 0.301226)
        #c2 = P(-1.1995, 0.128005)
        #c3 = P(-1.39355, -0.89644)
        #z2 = P(-0.817823, -0.554878)
        #c4 = P(2.29766, 1.29346)
        #c5 = P(10.3548, 7.10538)
        z3 = P(10.3548, 10.7118)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.0506356, 0.665825)
        #z1 = z0 + P(-0.967314, 0.301226)
        #c1 = z1 + P(0.378168, 0.282125)
        #c2 = z1 + P(-0.232191, -0.173221)
        #z2 = z1 + P(0.149491, -0.856104)
        #c3 = z2 + P(-0.575725, -0.341562)
        #c4 = z2 + P(3.11549, 1.84833)
        #z3 = z2 + P(11.1727, 11.2667)
        #c5 = z3 + P(0, -3.60645)

        z0 = P(0, -0)
        c0 = z0 + PP(0.667748, 85)
        z1 = z0 + PP(1.01313, 162)
        c1 = z1 + PP(0.47181, 36)
        c2 = z1 + PP(0.289686, -143)
        z2 = z1 + PP(0.869058, -80)
        #z2 = z3 - PP(15.8672, ta + 315)
        c3 = z2 + PP(0.66942, -149)
        c4 = z2 + PP(3.62251, 30)
        z3 = z2 + PP(15.8672, 45)
        c5 = z3 + PP(3.60645, -90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 28
0
    def path_CLNEL_bend(cls, ta=None, **kwargs):
        #M 116.53,85.1045 C 116.695,83.2189 114.881,83.4309 113.799,84.217 113.143,84.7112 112.6,87.6204 114.226,86.6431 123.119,81.5088 151.1425,63.692278 146.031,54.8389

        #z0 = P(0, -0)
        #c0 = P(0.0582083, 0.665198)
        #c1 = P(-0.581731, 0.590409)
        #z1 = P(-0.963436, 0.31309)
        #c2 = P(-1.19486, 0.138747)
        #c3 = P(-1.38642, -0.887554)
        #z2 = P(-0.8128, -0.542784)
        #c4 = P(2.32445, 1.26848)
        #c5 = P(12.2105, 7.55376)
        z3 = P(10.4073, 10.677)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.0582083, 0.665198)
        #z1 = z0 + P(-0.963436, 0.31309)
        #c1 = z1 + P(0.381706, 0.277319)
        #c2 = z1 + P(-0.231422, -0.174343)
        #z2 = z1 + P(0.150636, -0.855874)
        #c3 = z2 + P(-0.573617, -0.34477)
        #c4 = z2 + P(3.13725, 1.81127)
        #z3 = z2 + P(11.2201, 11.2198)
        #c5 = z3 + P(1.80322, -3.12328)

        z0 = P(0, -0)
        c0 = z0 + PP(0.66774, 84)
        z1 = z0 + PP(1.01303, 161)
        c1 = z1 + PP(0.47181, 35)
        c2 = z1 + PP(0.289744, -143)
        z2 = z1 + PP(0.869029, -80)
        #z2 = z3 - PP(15.8674, ta + 284)
        c3 = z2 + PP(0.669255, -148)
        c4 = z2 + PP(3.62257, 29)
        z3 = z2 + PP(15.8674, 44)
        c5 = z3 + PP(3.60645, -60)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 29
0
    def path_selNELCR(cls, ta=None, **kwargs):
        #M 70.0186,699.134 C 81.477412,699.1097 92.277737,671.52641 93.486737,661.67641 93.948737,658.38941 96.147737,660.93241 96.131737,661.81441 96.131737,662.97941 95.235737,663.96441 92.886737,664.08741

        #z0 = P(0, -0)
        #c0 = P(4.04241, 0.0085725)
        #c1 = P(7.85253, 9.73934)
        #z1 = P(8.27904, 13.2142)
        #c2 = P(8.44202, 14.3738)
        #c3 = P(9.21778, 13.4767)
        #z2 = P(9.21213, 13.1655)
        #c4 = P(9.21213, 12.7545)
        #c5 = P(8.89605, 12.407)
        z3 = P(8.06737, 12.3637)

        #z0 = P(0, -0)
        #c0 = z0 + P(4.04241, 0.0085725)
        #z1 = z0 + P(8.27904, 13.2142)
        #c1 = z1 + P(-0.426508, -3.47486)
        #c2 = z1 + P(0.162983, 1.15958)
        #z2 = z1 + P(0.933097, -0.0486833)
        #c3 = z2 + P(0.00564444, 0.31115)
        #c4 = z2 + P(0, -0.410986)
        #z3 = z2 + P(-1.14476, -0.801864)
        #c5 = z3 + P(0.828675, 0.0433917)

        z0 = P(0, -0)
        c0 = z0 + PP(4.04242, 0)
        z1 = z0 + PP(15.5935, 57)
        c1 = z1 + PP(3.50094, -96)
        c2 = z1 + PP(1.17098, 81)
        z2 = z1 + PP(0.934366, -2)
        #z2 = z3 - PP(1.39767, ta + 34)
        c3 = z2 + PP(0.311201, 88)
        c4 = z2 + PP(0.410986, -90)
        z3 = z2 + PP(1.39767, -144)
        c5 = z3 + PP(0.82981, 2)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 30
0
    def path_nerSWRCL(cls, ta=None, **kwargs):
        #M 404.114,645.28 C 410.21232,651.18793 392.6,683.603 383.213,684.59 380.401,684.935 382.665,686.796 383.489,687.215 384.728,687.82 385.563,685.578 385.259,684.149

        #z0 = P(0, -0)
        #c0 = P(2.15135, -2.08419)
        #c1 = P(-4.06188, -13.5195)
        #z1 = P(-7.37341, -13.8677)
        #c2 = P(-8.36542, -13.9894)
        #c3 = P(-7.56673, -14.6459)
        #z2 = P(-7.27604, -14.7937)
        #c4 = P(-6.83895, -15.0072)
        #c5 = P(-6.54438, -14.2162)
        z3 = P(-6.65162, -13.7121)

        #z0 = P(0, -0)
        #c0 = z0 + P(2.15135, -2.08419)
        #z1 = z0 + P(-7.37341, -13.8677)
        #c1 = z1 + P(3.31152, 0.348192)
        #c2 = z1 + P(-0.992011, -0.121708)
        #z2 = z1 + P(0.0973667, -0.926042)
        #c3 = z2 + P(-0.290689, 0.147814)
        #c4 = z2 + P(0.437092, -0.213431)
        #z3 = z2 + P(0.624417, 1.08162)
        #c5 = z3 + P(0.107244, -0.504119)

        z0 = P(0, -0)
        c0 = z0 + PP(2.99535, -44)
        z1 = z0 + PP(15.7061, -117)
        c1 = z1 + PP(3.32978, 6)
        c2 = z1 + PP(0.999449, -173)
        z2 = z1 + PP(0.931146, -83)
        #2 = z3 - PP(1.24892, ta + 317)
        c3 = z2 + PP(0.326112, 153)
        c4 = z2 + PP(0.486417, -26)
        z3 = z2 + PP(1.24892, 60)
        c5 = z3 + PP(0.515401, -77)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 31
0
    def path_erSWRCL(cls, ta=None, **kwargs):
        #M 352.442,277.109 C 360.00418,286.42895 340.929,315.432 331.541,316.419 328.729,316.764 330.994,318.625 331.817,319.045 333.056,319.649 333.891,317.407 333.588,315.978

        #z0 = P(0, -0)
        #c0 = P(2.66777, -3.28787)
        #c1 = P(-4.06153, -13.5195)
        #z1 = P(-7.37341, -13.8677)
        #c2 = P(-8.36542, -13.9894)
        #c3 = P(-7.56638, -14.6459)
        #z2 = P(-7.27604, -14.7941)
        #c4 = P(-6.83895, -15.0072)
        #c5 = P(-6.54438, -14.2162)
        z3 = P(-6.65127, -13.7121)

        #z0 = P(0, -0)
        #c0 = z0 + P(2.66777, -3.28787)
        #z1 = z0 + P(-7.37341, -13.8677)
        #c1 = z1 + P(3.31188, 0.348192)
        #c2 = z1 + P(-0.992011, -0.121708)
        #z2 = z1 + P(0.0973667, -0.926394)
        #c3 = z2 + P(-0.290336, 0.148167)
        #c4 = z2 + P(0.437092, -0.213078)
        #z3 = z2 + P(0.624769, 1.08197)
        #c5 = z3 + P(0.106892, -0.504119)

        z0 = P(0, -0)
        c0 = z0 + PP(4.23404, -50)
        z1 = z0 + PP(15.7061, -117)
        c1 = z1 + PP(3.33013, 6)
        c2 = z1 + PP(0.999449, -173)
        z2 = z1 + PP(0.931497, -84)
        #z2 = z3 - PP(1.2494, ta + 317)
        c3 = z2 + PP(0.325958, 152)
        c4 = z2 + PP(0.486263, -25)
        z3 = z2 + PP(1.2494, 59)
        c5 = z3 + PP(0.515327, -78)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemplo n.º 32
0
	def __init__(self, style=None, pos=None):
		if pos==None :
			pos = self.getDefaultPoints();
		super(TensionCurve, self).__init__(style, Point.center(*pos));

		pathitems = []
		i = 0
		for p in pos:
			if i == 0:
				pathitems.append(beginknot(*pos[0].toTuple()))
			elif i == len(pos) - 1:
				pathitems.append(tensioncurve())
				pathitems.append(endknot(*pos[i].toTuple()))
			else:
				pathitems.append(tensioncurve())
				pathitems.append(smoothknot(*pos[i].toTuple()))
			i += 1
		self.path = metapost.path.path(pathitems)
Exemplo n.º 33
0
from pyx import *
from pyx.metapost.path import beginknot, endknot, smoothknot, tensioncurve

p1, p2, p3, p4, p5 = (0, 0), (2, 1.33), (1.3, 3), (0.33, 2.33), (1, 1.67)
openpath = metapost.path.path([
    beginknot(*p1), tensioncurve(), smoothknot(*p2), tensioncurve(),
    smoothknot(*p3), tensioncurve(), smoothknot(*p4), tensioncurve(),
    endknot(*p5)])
closedpath = metapost.path.path([
    smoothknot(*p1), tensioncurve(), smoothknot(*p2), tensioncurve(),
    smoothknot(*p3), tensioncurve(), smoothknot(*p4), tensioncurve(),
    smoothknot(*p5), tensioncurve()])
c = canvas.canvas()
for p in [p1, p2, p3, p4, p5]:
    c.fill(path.circle(p[0], p[1], 0.05), [color.rgb.red])
    c.fill(path.circle(p[0], p[1], 0.05), [color.rgb.red, trafo.translate(2, 0)])
c.stroke(openpath)
c.stroke(closedpath, [trafo.translate(2, 0)])

c.writeEPSfile("metapost")
c.writePDFfile("metapost")
c.writeSVGfile("metapost")