Exemple #1
0
    def path_CRERser(cls, ta=None, **kwargs):
        #M 96.127396,161.80258 C 95.995596,163.30858 95.7411,164.268 94.7102,164.376 94.0928,164.452 92.5039,163.606 93.486,162.968 97.8687,160.229 106.21094,160.65836 104.545,163.741

        #z0 = P(0, -0)
        #c0 = P(-0.0464961, -0.531283)
        #c1 = P(-0.136277, -0.869745)
        #z1 = P(-0.499955, -0.907845)
        #c2 = P(-0.71776, -0.934656)
        #c3 = P(-1.27829, -0.636206)
        #z2 = P(-0.931826, -0.411134)
        #c4 = P(0.614293, 0.555124)
        #c5 = P(3.55725, 0.403655)
        z3 = P(2.96954, -0.683832)

        #z0 = P(0, -0)
        #c0 = z0 + P(-0.0464961, -0.531283)
        #z1 = z0 + P(-0.499955, -0.907845)
        #c1 = z1 + P(0.363679, 0.0381)
        #c2 = z1 + P(-0.217805, -0.0268111)
        #z2 = z1 + P(-0.431871, 0.496711)
        #c3 = z2 + P(-0.346463, -0.225072)
        #c4 = z2 + P(1.54612, 0.966258)
        #z3 = z2 + P(3.90137, -0.272697)
        #c5 = z3 + P(0.587707, 1.08749)

        z0 = P(0, -0)
        c0 = z0 + PP(0.533314, -95)
        z1 = z0 + PP(1.03641, -118)
        c1 = z1 + PP(0.365669, 5)
        c2 = z1 + PP(0.219449, -172)
        z2 = z1 + PP(0.658205, 131)
        #z2 = z3 - PP(3.91089, ta + 116)
        c3 = z2 + PP(0.413151, -146)
        c4 = z2 + PP(1.82322, 32)
        z3 = z2 + PP(3.91089, -3)
        c5 = z3 + PP(1.23613, 61)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #2
0
    def path_UWLSF(cls, ta=None, **kwargs):
        #M 52.827226,64.384752 C 49.932313,65.307965 47.630826,67.501952 47.630826,70.362452 47.630826,73.195052 51.039826,74.841752 53.992126,73.465152 53.992126,74.410034 53.992126,75.354916 53.992126,76.299798

        #z0 = P(0, -0)
        #c0 = P(-1.02126, -0.325689)
        #c1 = P(-1.83317, -1.09968)
        #z1 = P(-1.83317, -2.1088)
        #c2 = P(-1.83317, -3.10808)
        #c3 = P(-0.630555, -3.689)
        #z2 = P(0.410951, -3.20336)
        #c4 = P(0.410951, -3.5367)
        #c5 = P(0.410951, -3.87003)
        z3 = P(0.410951, -4.20336)

        #z0 = P(0, -0)
        #c0 = z0 + P(-1.02126, -0.325689)
        #z1 = z0 + P(-1.83317, -2.1088)
        #c1 = z1 + P(0, 1.00912)
        #c2 = z1 + P(0, -0.999278)
        #z2 = z1 + P(2.24413, -1.09456)
        #c3 = z2 + P(-1.04151, -0.485634)
        #c4 = z2 + P(0, -0.333333)
        #z3 = z2 + P(0, -1)
        #c5 = z3 + P(0, 0.333333)

        z0 = P(0, -0)
        c0 = z0 + PP(1.07194, -162)
        z1 = z0 + PP(2.7942, -131)
        c1 = z1 + PP(1.00912, 90)
        c2 = z1 + PP(0.999278, -90)
        z2 = z1 + PP(2.49683, -26)
        #z2 = z3 - PP(1, ta + 0)
        c3 = z2 + PP(1.14916, -155)
        c4 = z2 + PP(0.333333, -90)
        z3 = z2 + PP(1, -90)
        c5 = z3 + PP(0.333333, 90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #3
0
    def path_selNELCRne(cls, ta=None, **kwargs):
        #M 384.999,616.183 C 396.458,616.183 408.036,588.981 409.073,579.112 409.593,575.833 411.36583,577.58228 411.33483,578.46328 411.33483,579.62828 410.36231,580.17697 408.515,581.533

        #z0 = P(0, -0)
        #c0 = P(4.04248, -0)
        #c1 = P(8.12694, 9.59626)
        #z1 = P(8.49277, 13.0778)
        #c2 = P(8.67622, 14.2346)
        #c3 = P(9.30163, 13.6175)
        #z2 = P(9.2907, 13.3067)
        #c4 = P(9.2907, 12.8957)
        #c5 = P(8.94761, 12.7021)
        z3 = P(8.29592, 12.2237)

        #z0 = P(0, -0)
        #c0 = z0 + P(4.04248, 0)
        #z1 = z0 + P(8.49277, 13.0778)
        #c1 = z1 + P(-0.365831, -3.48156)
        #c2 = z1 + P(0.183444, 1.15676)
        #z2 = z1 + P(0.797923, 0.228854)
        #c3 = z2 + P(0.0109361, 0.310797)
        #c4 = z2 + P(0, -0.410986)
        #z3 = z2 + P(-0.994773, -1.08293)
        #c5 = z3 + P(0.65169, 0.478377)

        z0 = P(0, -0)
        c0 = z0 + PP(4.04248, 0)
        z1 = z0 + PP(15.5935, 57)
        c1 = z1 + PP(3.50073, -95)
        c2 = z1 + PP(1.17121, 80)
        z2 = z1 + PP(0.830094, 16)
        #z2 = z3 - PP(1.47048, ta + 12)
        c3 = z2 + PP(0.31099, 87)
        c4 = z2 + PP(0.410986, -90)
        z3 = z2 + PP(1.47048, -132)
        #c5 = z3 + PP(0.808421, 36)
        c5 = z3 + PP(0.808421, ta)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemple #4
0
    def path_CRER(cls, ta=None, **kwargs):
        #M 51.577794,55.996783 C 51.424916,57.500559 51.06808,58.587765 50.037375,58.698316 49.418922,58.764649 47.797323,57.930714 48.790331,57.310208 53.17309,54.571528 59.849175,54.587713 59.849175,58.092613

        #z0 = P(0, -0)
        #c0 = P(-0.053932, -0.530499)
        #c1 = P(-0.179816, -0.914041)
        #z1 = P(-0.543426, -0.953041)
        #c2 = P(-0.761602, -0.976442)
        #c3 = P(-1.33367, -0.682248)
        #z2 = P(-0.983355, -0.463347)
        #c4 = P(0.562785, 0.502798)
        #c5 = P(2.91796, 0.497089)
        z3 = P(2.91796, -0.739362)

        #z0 = P(0, -0)
        #c0 = z0 + P(-0.053932, -0.530499)
        #z1 = z0 + P(-0.543426, -0.953041)
        #c1 = z1 + P(0.36361, 0.0389999)
        #c2 = z1 + P(-0.218176, -0.0234008)
        #z2 = z1 + P(-0.439929, 0.489694)
        #c3 = z2 + P(-0.350311, -0.218901)
        #c4 = z2 + P(1.54614, 0.966145)
        #z3 = z2 + P(3.90131, -0.276015)
        #c5 = z3 + P(0, 1.23645)

        z0 = P(0, -0)
        c0 = z0 + PP(0.533233, -95)
        z1 = z0 + PP(1.09709, -119)
        c1 = z1 + PP(0.365695, 6)
        c2 = z1 + PP(0.219428, -173)
        z2 = z1 + PP(0.658284, 131)
        #z2 = z3 - PP(3.91107, ta + 86)
        c3 = z2 + PP(0.41308, -147)
        c4 = z2 + PP(1.82318, 32)
        z3 = z2 + PP(3.91107, -4)
        c5 = z3 + PP(1.23645, 90)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #5
0
    def path_CLSEL_swingup(cls, ta=None, **kwargs):
        #M 124.14222,272.1685 C 125.46851,272.73746 127.0205,272.03649 126.81119,270.72407 126.48726,268.69306 124.01606,267.5455 124.05286,269.95172 124.28893,285.38691 131.977,288.723 135.91,281.911

        #z0 = P(0, -0)
        #c0 = P(0.467886, -0.200716)
        #c1 = P(1.01539, 0.0465702)
        #z1 = P(0.941553, 0.509563)
        #c2 = P(0.827278, 1.22606)
        #c3 = P(-0.0445064, 1.63089)
        #z2 = P(-0.0315242, 0.782031)
        #c4 = P(0.051756, -4.66316)
        #c5 = P(2.76394, -5.84006)
        z3 = P(4.15141, -3.43694)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.467886, -0.200716)
        #z1 = z0 + P(0.941553, 0.509563)
        #c1 = z1 + P(0.0738399, -0.462993)
        #c2 = z1 + P(-0.114275, 0.716495)
        #z2 = z1 + P(-0.973078, 0.272468)
        #c3 = z2 + P(-0.0129822, 0.848861)
        #c4 = z2 + P(0.0832802, -5.44519)
        #z3 = z2 + P(4.18294, -4.21897)
        #c5 = z3 + P(-1.38747, -2.40312)

        z0 = P(0, -0)
        c0 = z0 + PP(0.509121, -23)
        z1 = z0 + PP(1.0706, 28)
        c1 = z1 + PP(0.468844, -80)
        c2 = z1 + PP(0.725551, 99)
        z2 = z1 + PP(1.0105, 164)
        #z2 = z3 - PP(5.9411, ta + 255)
        c3 = z2 + PP(0.84896, 90)
        c4 = z2 + PP(5.44583, -89)
        z3 = z2 + PP(5.9411, -45)
        c5 = z3 + PP(2.7749, -120)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #6
0
    def path_CRERsr(cls, ta=None, **kwargs):
        #M 202.66985,117.55238 C 202.53885,119.05838 202.25,120.067 201.219,120.175 200.601,120.251 199.012,119.404 199.995,118.767 204.377,116.028 213.2073,115.81038 211.054,119.54

        #z0 = P(0, -0)
        #c0 = P(-0.0462139, -0.531283)
        #c1 = P(-0.148114, -0.887102)
        #z1 = P(-0.511828, -0.925202)
        #c2 = P(-0.729844, -0.952013)
        #c3 = P(-1.29041, -0.65321)
        #z2 = P(-0.943628, -0.428491)
        #c4 = P(0.602245, 0.537767)
        #c5 = P(3.71738, 0.614539)
        z3 = P(2.95774, -0.701188)

        #z0 = P(0, -0)
        #c0 = z0 + P(-0.0462139, -0.531283)
        #z1 = z0 + P(-0.511828, -0.925202)
        #c1 = z1 + P(0.363714, 0.0381)
        #c2 = z1 + P(-0.218017, -0.0268111)
        #z2 = z1 + P(-0.4318, 0.496711)
        #c3 = z2 + P(-0.346781, -0.224719)
        #c4 = z2 + P(1.54587, 0.966258)
        #z3 = z2 + P(3.90137, -0.272697)
        #c5 = z3 + P(0.759636, 1.31573)

        z0 = P(0, -0)
        c0 = z0 + PP(0.53329, -94)
        z1 = z0 + PP(1.05734, -118)
        c1 = z1 + PP(0.365704, 5)
        c2 = z1 + PP(0.219659, -172)
        z2 = z1 + PP(0.658159, 131)
        #z2 = z3 - PP(3.91089, ta + 118)
        c3 = z2 + PP(0.413226, -147)
        c4 = z2 + PP(1.82301, 32)
        z3 = z2 + PP(3.91089, -3)
        c5 = z3 + PP(1.51927, 59)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #7
0
    def path_CRSE(cls, ta=None, **kwargs):
        #M 48.648192,55.649308 C 47.132035,56.220999 45.609894,55.835104 45.405607,54.730411 45.258329,53.933999 46.43975,51.62983 47.351786,53.275743 49.204743,56.619697 51.003251,59.745855 52.732687,62.595723

        #z0 = P(0, -0)
        #c0 = P(-0.534866, -0.20168)
        #c1 = P(-1.07184, -0.0655447)
        #z1 = P(-1.14391, 0.324166)
        #c2 = P(-1.19587, 0.605123)
        #c3 = P(-0.779089, 1.41798)
        #z2 = P(-0.457343, 0.837341)
        #c4 = P(0.196339, -0.342332)
        #c5 = P(0.830812, -1.44517)
        z3 = P(1.44092, -2.45054)

        #z0 = P(0, -0)
        #c0 = z0 + P(-0.534866, -0.20168)
        #z1 = z0 + P(-1.14391, 0.324166)
        #c1 = z1 + P(0.0720679, -0.389711)
        #c2 = z1 + P(-0.0519564, 0.280956)
        #z2 = z1 + P(0.686569, 0.513175)
        #c3 = z2 + P(-0.321746, 0.580642)
        #c4 = z2 + P(0.653682, -1.17967)
        #z3 = z2 + P(1.89826, -3.28788)
        #c5 = z3 + P(-0.610107, 1.00537)

        z0 = P(0, -0)
        c0 = z0 + PP(0.571627, -159)
        z1 = z0 + PP(1.18896, 164)
        c1 = z1 + PP(0.396319, -79)
        c2 = z1 + PP(0.28572, 100)
        z2 = z1 + PP(0.857161, 36)
        #z2 = z3 - PP(3.79652, ta + 0)
        c3 = z2 + PP(0.663826, 118)
        c4 = z2 + PP(1.34868, -61)
        z3 = z2 + PP(3.79652, -59)
        c5 = z3 + PP(1.17601, 121)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #8
0
    def path_CLSEL(cls, ta=None, **kwargs):
        #M 47.38479,61.727859 C 47.38479,62.255724 49.627111,61.080093 49.723858,60.143329 49.872882,58.70038 47.435984,57.028382 47.433719,59.677728 47.424567,70.382424 49.620065,75.647429 59.227265,75.647429

        #z0 = P(0, -0)
        #c0 = P(0, -0.186219)
        #c1 = P(0.791041, 0.228517)
        #z1 = P(0.825171, 0.558987)
        #c2 = P(0.877744, 1.06803)
        #c3 = P(0.0180601, 1.65787)
        #z2 = P(0.0172611, 0.723241)
        #c4 = P(0.0140324, -3.05314)
        #c5 = P(0.788555, -4.91051)
        z3 = P(4.17776, -4.91051)

        #z0 = P(0, -0)
        #c0 = z0 + P(0, -0.186219)
        #z1 = z0 + P(0.825171, 0.558987)
        #c1 = z1 + P(-0.0341302, -0.33047)
        #c2 = z1 + P(0.0525724, 0.50904)
        #z2 = z1 + P(-0.80791, 0.164254)
        #c3 = z2 + P(0.000799042, 0.93463)
        #c4 = z2 + P(-0.00322862, -3.77638)
        #z3 = z2 + P(4.1605, -5.63376)
        #c5 = z3 + P(-3.38921, 0)

        z0 = P(0, -0)
        c0 = z0 + PP(0.186219, -90)
        z1 = z0 + PP(0.996681, 34)
        c1 = z1 + PP(0.332227, -95)
        c2 = z1 + PP(0.511748, 84)
        z2 = z1 + PP(0.824438, 168)
        #z2 = z3 - PP(7.0035, ta + -53)
        c3 = z2 + PP(0.934631, 89)
        c4 = z2 + PP(3.77638, -90)
        z3 = z2 + PP(7.0035, -53)
        c5 = z3 + PP(3.38921, 180)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #9
0
    def path_CSEL(cls, ta=None, **kwargs):
        #M 40.670877,58.870121 C 40.670877,60.879404 42.333669,63.011502 43.801655,64.630416 44.768079,65.696201 46.990649,67.642971 47.374699,67.051621 47.943699,65.831421 42.286235,59.249753 40.657435,58.873753

        #z0 = P(0, -0)
        #c0 = P(0, -0.70883)
        #c1 = P(0.586596, -1.46099)
        #z1 = P(1.10447, -2.0321)
        #c2 = P(1.4454, -2.40809)
        #c3 = P(2.22948, -3.09487)
        #z2 = P(2.36496, -2.88625)
        #c4 = P(2.56569, -2.45579)
        #c5 = P(0.569862, -0.133926)
        z3 = P(-0.00474204, -0.00128129)

        #z0 = P(0, -0)
        #c0 = z0 + P(0, -0.70883)
        #z1 = z0 + P(1.10447, -2.0321)
        #c1 = z1 + P(-0.517873, 0.571117)
        #c2 = z1 + P(0.340933, -0.375985)
        #z2 = z1 + P(1.26049, -0.854147)
        #c3 = z2 + P(-0.135484, -0.208615)
        #c4 = z2 + P(0.200731, 0.430459)
        #z3 = z2 + P(-2.3697, 2.88497)
        #c5 = z3 + P(0.574604, -0.132644)

        z0 = P(0, -0)
        c0 = z0 + PP(0.70883, -90)
        z1 = z0 + PP(2.31286, -61)
        c1 = z1 + PP(0.770952, 132)
        c2 = z1 + PP(0.507543, -47)
        z2 = z1 + PP(1.52263, -34)
        #z2 = z3 - PP(3.73344, ta + 321)
        c3 = z2 + PP(0.248749, -123)
        c4 = z2 + PP(0.474961, 64)
        z3 = z2 + PP(3.73344, 129)
        c5 = z3 + PP(0.589716, -12)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #10
0
    def path_elcl1CSEL(cls, ta=None, **kwargs):
        #M 40.670877,58.870121 C 41.838342,60.379062 43.247769,62.355728 44.635559,64.018887 45.508296,65.064795 47.245322,67.744767 47.374699,67.051621 47.989938,63.755431 43.319633,58.216355 40.657435,58.873753

        #z0 = P(0, -0)
        #c0 = P(0.411856, -0.532321)
        #c1 = P(0.90907, -1.22964)
        #z1 = P(1.39865, -1.81637)
        #c2 = P(1.70653, -2.18534)
        #c3 = P(2.31932, -3.13078)
        #z2 = P(2.36496, -2.88625)
        #c4 = P(2.582, -1.72343)
        #c5 = P(0.934422, 0.230634)
        z3 = P(-0.00474204, -0.00128129)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.411856, -0.532321)
        #z1 = z0 + P(1.39865, -1.81637)
        #c1 = z1 + P(-0.489581, 0.586726)
        #c2 = z1 + P(0.307882, -0.368973)
        #z2 = z1 + P(0.966308, -1.06988)
        #c3 = z2 + P(-0.0456413, -0.244527)
        #c4 = z2 + P(0.217043, 1.16282)
        #z3 = z2 + P(-2.3697, 2.88497)
        #c5 = z3 + P(0.939164, 0.231915)

        z0 = P(0, -0)
        c0 = z0 + PP(0.673046, -52)
        z1 = z0 + PP(2.29247, -52)
        c1 = z1 + PP(0.764158, 129)
        c2 = z1 + PP(0.480554, -50)
        z2 = z1 + PP(1.44166, -47)
        #z2 = z3 - PP(3.73344, ta + 296)
        c3 = z2 + PP(0.24875, -100)
        c4 = z2 + PP(1.1829, 79)
        z3 = z2 + PP(3.73344, 129)
        c5 = z3 + PP(0.967375, 13)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #11
0
    def path_NELCRne(cls, ta=None, **kwargs):
        #M 47.3414,100.939 C 55.8544,95.1967 77.9908,80.0238 79.2003,70.173 79.6622,66.8863 81.261289,68.679761 81.245889,69.562461 81.245889,70.727761 80.349389,71.262578 78.5994,72.5844

        #z0 = P(0, -0)
        #c0 = P(3.0032, 2.02576)
        #c1 = P(10.8124, 7.37842)
        #z1 = P(11.2391, 10.8536)
        #c2 = P(11.4021, 12.013)
        #c3 = P(11.9662, 11.3803)
        #z2 = P(11.9608, 11.0689)
        #c4 = P(11.9608, 10.6579)
        #c5 = P(11.6445, 10.4692)
        z3 = P(11.0271, 10.0029)

        #z0 = P(0, -0)
        #c0 = z0 + P(3.0032, 2.02576)
        #z1 = z0 + P(11.2391, 10.8536)
        #c1 = z1 + P(-0.426685, -3.47514)
        #c2 = z1 + P(0.162948, 1.15947)
        #z2 = z1 + P(0.721638, 0.215385)
        #c3 = z2 + P(0.00543278, 0.311397)
        #c4 = z2 + P(0, -0.411092)
        #z3 = z2 + P(-0.933623, -1.06607)
        #c5 = z3 + P(0.617357, 0.466309)

        z0 = P(0, -0)
        c0 = z0 + PP(3.62255, 34)
        z1 = z0 + PP(15.6243, 44)
        c1 = z1 + PP(3.50124, -96)
        c2 = z1 + PP(1.17087, 82)
        z2 = z1 + PP(0.753095, 16)
        #z2 = z3 - PP(1.4171, ta + 12)
        c3 = z2 + PP(0.311444, 89)
        c4 = z2 + PP(0.411092, -90)
        z3 = z2 + PP(1.4171, -131)
        #c5 = z3 + PP(0.773676, 37)
        c5 = z3 + PP(0.773676, ta)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemple #12
0
    def path_CLE(cls, ta=None, **kwargs):
        #M 51.745803,57.564901 C 52.047123,56.505618 52.284213,54.900984 49.77316,55.093299 48.200828,55.21372 46.835601,57.564901 49.198615,57.564901 56.39782,57.564901 63.597026,57.564901 70.796231,57.564901

        #z0 = P(0, -0)
        #c0 = P(0.106299, 0.373692)
        #c1 = P(0.189939, 0.939771)
        #z1 = P(-0.695905, 0.871926)
        #c2 = P(-1.25059, 0.829444)
        #c3 = P(-1.73221, -0)
        #z2 = P(-0.898591, -0)
        #c4 = P(1.64113, -0)
        #c5 = P(4.18085, -0)
        z3 = P(6.72057, -0)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.106299, 0.373692)
        #z1 = z0 + P(-0.695905, 0.871926)
        #c1 = z1 + P(0.885844, 0.0678445)
        #c2 = z1 + P(-0.554684, -0.0424819)
        #z2 = z1 + P(-0.202687, -0.871926)
        #c3 = z2 + P(-0.833619, 0)
        #c4 = z2 + P(2.53972, 0)
        #z3 = z2 + P(7.61916, 0)
        #c5 = z3 + P(-2.53972, 0)

        z0 = P(1.45, 0)
        c0 = z0 + PP(0.388516, 74)
        z1 = z0 + PP(1.11559, 128)
        c1 = z1 + PP(0.888438, 4)
        c2 = z1 + PP(0.556308, -175)
        z2 = z1 + PP(0.895174, -103)
        #z2 = z3 - PP(7.61916, ta + 0)
        c3 = z2 + PP(0.833619, 180)
        c4 = z2 + PP(2.53972, 0)
        z3 = z2 + PP(7.61916, 0)
        c5 = z3 + PP(2.53972, 180)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #13
0
    def path_CLSELne(cls, ta=None, **kwargs):
        #M 419.775,129.159 C 421.103,129.723 422.685,129.043 422.454,127.734 422.133,125.703 419.701,124.538 419.701,126.945 419.97,142.38 432.79809,143.29075 431.609,138.853

        #z0 = P(0, -0)
        #c0 = P(0.468489, -0.198967)
        #c1 = P(1.02658, 0.0409222)
        #z1 = P(0.945092, 0.502708)
        #c2 = P(0.83185, 1.2192)
        #c3 = P(-0.0261056, 1.63019)
        #z2 = P(-0.0261056, 0.78105)
        #c4 = P(0.0687917, -4.66408)
        #c5 = P(4.59426, -4.98537)
        z3 = P(4.17477, -3.41983)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.468489, -0.198967)
        #z1 = z0 + P(0.945092, 0.502708)
        #c1 = z1 + P(0.0814917, -0.461786)
        #c2 = z1 + P(-0.113242, 0.716492)
        #z2 = z1 + P(-0.971197, 0.278342)
        #c3 = z2 + P(0, 0.849136)
        #c4 = z2 + P(0.0948972, -5.44513)
        #z3 = z2 + P(4.20088, -4.20088)
        #c5 = z3 + P(0.419485, -1.56554)

        z0 = P(0, -0)
        c0 = z0 + PP(0.508989, -23)
        z1 = z0 + PP(1.07047, 28)
        c1 = z1 + PP(0.468921, -79)
        c2 = z1 + PP(0.725385, 98)
        z2 = z1 + PP(1.0103, 164)
        #z2 = z3 - PP(5.94094, ta + 210)
        c3 = z2 + PP(0.849136, 90)
        c4 = z2 + PP(5.44595, -89)
        z3 = z2 + PP(5.94094, -45)
        c5 = z3 + PP(1.62077, -75)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #14
0
    def path_CLE(cls, ta=None, **kwargs):
        #M 131.7682,104.83671 C 132.1981,104.13513 131.20453,102.24132 130.02357,102.62658 129.01934,102.95418 127.97218,104.99017 129.07753,104.99836 139.50785,105.07567 173.91687,104.99836 173.91687,104.99836

        #z0 = P(0, -0)
        #c0 = P(0.151659, 0.247502)
        #c1 = P(-0.19885, 0.915596)
        #z1 = P(-0.615467, 0.779685)
        #c2 = P(-0.969737, 0.664115)
        #c3 = P(-1.33915, -0.0541373)
        #z2 = P(-0.949209, -0.0570265)
        #c4 = P(2.73038, -0.0842998)
        #c5 = P(14.8691, -0.0570265)
        z3 = P(14.8691, -0.0570265)

        #z0 = P(0, -0)
        #c0 = z0 + P(0.151659, 0.247502)
        #z1 = z0 + P(-0.615467, 0.779685)
        #c1 = z1 + P(0.416616, 0.135911)
        #c2 = z1 + P(-0.35427, -0.11557)
        #z2 = z1 + P(-0.333742, -0.836711)
        #c3 = z2 + P(-0.389943, 0.00288925)
        #c4 = z2 + P(3.67959, -0.0272732)
        #z3 = z2 + P(15.8183, 0)
        #c5 = z3 + P(0, 0)

        z0 = P(-1.3, 0)
        c0 = z0 + PP(0.290272, 58)
        z1 = z0 + PP(0.993332, 128)
        c1 = z1 + PP(0.438225, 18)
        c2 = z1 + PP(0.372644, -161)
        z2 = z1 + PP(0.900816, -111)
        #z2 = z3 - PP(15.8183, ta + 180)
        c3 = z2 + PP(0.389954, 179)
        c4 = z2 + PP(3.67969, 0)
        z3 = z2 + PP(15.8183, 0)
        c5 = z3 + PP(0, 0)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #15
0
    def path_CLSELnel(cls, ta=None, **kwargs):
        #M 162.77806,130.35036 C 162.77806,130.87836 164.97751,129.70135 165.12106,128.77036 165.3372,127.36865 161.57416,125.76095 162.18115,128.33885 164.48312,138.11534 171.55212,144.13936 174.78206,144.13936

        #z0 = P(0, -0)
        #c0 = P(0, -0.186267)
        #c1 = P(0.775917, 0.228956)
        #z1 = P(0.826558, 0.557389)
        #c2 = P(0.902808, 1.05188)
        #c3 = P(-0.424709, 1.61904)
        #z2 = P(-0.210577, 0.709616)
        #c4 = P(0.601507, -2.73931)
        #c5 = P(3.09529, -4.86445)
        z3 = P(4.23474, -4.86445)

        #z0 = P(0, -0)
        #c0 = z0 + P(0, -0.186267)
        #z1 = z0 + P(0.826558, 0.557389)
        #c1 = z1 + P(-0.0506413, -0.328433)
        #c2 = z1 + P(0.0762494, 0.494492)
        #z2 = z1 + P(-1.03713, 0.152227)
        #c3 = z2 + P(-0.214133, 0.909426)
        #c4 = z2 + P(0.812084, -3.44893)
        #z3 = z2 + P(4.44532, -5.57407)
        #c5 = z3 + P(-1.13945, 0)

        z0 = P(0, -0)
        c0 = z0 + PP(0.186267, -90)
        z1 = z0 + PP(0.996936, 33)
        c1 = z1 + PP(0.332314, -98)
        c2 = z1 + PP(0.500336, 81)
        z2 = z1 + PP(1.04825, 171)
        #z2 = z3 - PP(7.12959, ta + -51)
        c3 = z2 + PP(0.934296, 103)
        c4 = z2 + PP(3.54325, -76)
        z3 = z2 + PP(7.12959, -51)
        c5 = z3 + PP(1.13945, 180)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)
        ])
Exemple #16
0
    def path_CLEL_fusion(cls, ta=None, **kwargs):
        #M 51.203993,59.690008 C 51.036726,58.000756 50.850768,57.244589 49.768021,56.901977 48.08098,56.368149 45.926543,58.177645 48.928013,59.130518 54.725257,60.970962 69.1064,63.8503 70.0186,58.6772

        #z0 = P(0, -0)
        #c0 = P(-0.0590081, 0.595931)
        #c1 = P(-0.12461, 0.862689)
        #z1 = P(-0.506579, 0.983555)
        #c2 = P(-1.10173, 1.17188)
        #c3 = P(-1.86177, 0.533528)
        #z2 = P(-0.802915, 0.197376)
        #c4 = P(1.24222, -0.451892)
        #c5 = P(6.31557, -1.46766)
        z3 = P(6.63738, 0.357296)

        #z0 = P(0, -0)
        #c0 = z0 + P(-0.0590081, 0.595931)
        #z1 = z0 + P(-0.506579, 0.983555)
        #c1 = z1 + P(0.381969, -0.120866)
        #c2 = z1 + P(-0.595151, 0.188323)
        #z2 = z1 + P(-0.296336, -0.78618)
        #c3 = z2 + P(-1.05885, 0.336152)
        #c4 = z2 + P(2.04514, -0.649268)
        #z3 = z2 + P(7.44029, 0.159921)
        #c5 = z3 + P(-0.321804, -1.82495)

        z0 = P(0, -0)
        c0 = z0 + PP(0.598845, 95)
        z1 = z0 + PP(1.10635, 117)
        c1 = z1 + PP(0.400636, -17)
        c2 = z1 + PP(0.624235, 162)
        z2 = z1 + PP(0.840175, -110)
        #z2 = z3 - PP(7.44201, ta + 281)
        c3 = z2 + PP(1.11093, 162)
        c4 = z2 + PP(2.14573, -17)
        z3 = z2 + PP(7.44201, 1)
        c5 = z3 + PP(1.85311, -100)

        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)
        ])
Exemple #17
0
    def path_P(cls, ta=None, **kwargs):
        z0 = P(0, -0)
        c0 = z0
        z1 = z0 + PP(0.01, -90)
        c1 = z1

        return pyx.metapost.path.path([
            pyx.metapost.path.beginknot(*z0),
            pyx.metapost.path.controlcurve(c0, c1),
            pyx.metapost.path.endknot(*z1)
        ])
Exemple #18
0
    def draw_dot(self, canvas, linewidth=0.3, color=None, dot=P(0, 0)):
        if color is None:
            color = self.color

        p = pyx.path.path(pyx.path.moveto(*dot),
                          pyx.path.rlineto(*PP(0.1, -45)))

        canvas.stroke(p.transformed(trafo.translate(*self.head)), [
            style.linecap.round,
            style.linewidth(linewidth), style.linejoin.round, color
        ])
Exemple #19
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)])
Exemple #20
0
    def path_ELCLswr(cls, ta=None, **kwargs):
        #M 295.345,116.908 C 299.523,119.037 306.115,120.376 306.727,116.908 307.12,114.886 303.25196,114.15843 304.129,116.163 304.60988,117.26211 304.81434,117.69433 305.02255,118.76802

        #z0 = P(0, -0)
        #c0 = P(1.47391, -0.751064)
        #c1 = P(3.79942, -1.22343)
        #z1 = P(4.01532, -0)
        #c2 = P(4.15396, 0.713317)
        #c3 = P(2.7894, 0.969987)
        #z2 = P(3.0988, 0.262819)
        #c4 = P(3.26844, -0.124922)
        #c5 = P(3.34057, -0.2774)
        #z3 = P(3.41402, -0.656174)

        #z0 = P(0, -0)
        #c0 = z0 + P(1.47391, -0.751064)
        #z1 = z0 + P(4.01532, 0)
        #c1 = z1 + P(-0.2159, -1.22343)
        #c2 = z1 + P(0.138642, 0.713317)
        #z2 = z1 + P(-0.916517, 0.262819)
        #c3 = z2 + P(-0.3094, 0.707168)
        #c4 = z2 + P(0.169644, -0.387742)
        #z3 = z2 + P(0.315225, -0.918993)
        #c5 = z3 + P(-0.0734519, 0.378774)

        z0 = P(0, -0)
        c0 = z0 + PP(1.65424, -27)
        z1 = z0 + PP(4.01532, 0)
        c1 = z1 + PP(1.24234, -100)
        c2 = z1 + PP(0.726665, 79)
        z2 = z1 + PP(0.953455, 163)
        #z2 = z3 - PP(0.971553, ta + 9)
        c3 = z2 + PP(0.77189, 113)
        c4 = z2 + PP(0.423229, -66)
        z3 = z2 + PP(0.971553, -71)
        c5 = z3 + PP(0.38583, 100)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemple #21
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)])
Exemple #22
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)])
Exemple #23
0
    def path_ELCL(cls, ta=None, **kwargs):
        #M 0,0 C 4.14018,2.20137 10.722965,3.4592925 11.3811,0 11.766203,-2.0241783 7.6436587,-2.6701741 8.7739987,-0.71237408 9.4391687,0.43972692 9.43327,0.568554 10.2884,1.58764

        #z0 = P(0, 0)
        #c0 = P(1.46056, -0.776594)
        #c1 = P(3.78282, -1.22036)
        #z1 = P(4.015, 0)
        #c2 = P(4.15085, 0.714085)
        #c3 = P(2.69651, 0.941978)
        #z2 = P(3.09527, 0.25131)
        #c4 = P(3.32993, -0.155126)
        #c5 = P(3.32785, -0.200573)
        #z3 = P(3.62952, -0.560084)

        #z0 = P(0, 0)
        #c0 = z0 + P(1.46056, -0.776594)
        #z1 = z0 + P(4.015, 0)
        #c1 = z1 + P(-0.232175, -1.22036)
        #c2 = z1 + P(0.135856, 0.714085)
        #z2 = z1 + P(-0.919727, 0.25131)
        #c3 = z2 + P(-0.398759, 0.690668)
        #c4 = z2 + P(0.234657, -0.406436)
        #z3 = z2 + P(0.534247, -0.811394)
        #c5 = z3 + P(-0.301671, 0.359511)

        z0 = P(0, 0)
        c0 = z0 + PP(1.65419, -27)
        z1 = z0 + PP(4.015, 0)
        c1 = z1 + PP(1.24225, -100)
        c2 = z1 + PP(0.726894, 79)
        z2 = z1 + PP(0.953444, 164)
        #z2 = z3 - PP(0.971483, ta + -6)
        c3 = z2 + PP(0.797516, 120)
        c4 = z2 + PP(0.469312, -59)
        z3 = z2 + PP(0.971483, -56)
        c5 = z3 + PP(0.469312, 130)

        return pyx.metapost.path.path([
            beginknot(*z0),
            controlcurve(c0, c1),
            knot(*z1),
            controlcurve(c2, c3),
            knot(*z2),
            controlcurve(c4, c5),
            #curve(),
            endknot(*z3)])
Exemple #24
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)])
Exemple #25
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)])
Exemple #26
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)])
Exemple #27
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)])
Exemple #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)])
Exemple #29
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)])
Exemple #30
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)])