Example #1
0
class BezierLine(object):
    def __init__(self):
        self._poscurve = Bezier([], [])
        self._hcurve = Bezier([], [])
        self._scurve = Bezier([], [])
        self._vcurve = Bezier([], [])
        self._radcurve = Bezier([], [])
        self._alphacurve = Bezier([], [])

    def setPos(self, xs, ys):
        self._poscurve = Bezier(xs, ys)

    def setHSV(self, hs, ss, vs):
        self._hcurve = Bezier(hs, [0] * len(hs))
        self._scurve = Bezier(ss, [0] * len(ss))
        self._vcurve = Bezier(vs, [0] * len(vs))

    def setRad(self, rads):
        self._radcurve = Bezier(rads, [0] * len(rads))

    def setAlpha(self, alpha):
        self._alphacurve = Bezier(alpha, [0] * len(alpha))

    def getPos(self, t):
        return self._poscurve(t)

    def getHSV(self, t):
        return self._hcurve(t)[0], self._scurve(t)[0], self._vcurve(t)[0]

    def getRGB(self, t):
        val = colorsys.hsv_to_rgb(
            self._hcurve(t)[0],
            self._scurve(t)[0],
            self._vcurve(t)[0])
        val2 = []
        for i in range(len(val)):
            val2 += [val[i] * 256]
        return tuple(val2)

    def getRad(self, t):
        return self._radcurve(t)[0]

    def getAlpha(self, t):
        return self._alphacurve(t)[0]

    def draw(self, drw, mirror=True):
        time = 0
        dt = .005
        xold, yold = self.getPos(time)
        x, y = self.getPos(time + dt)
        ds = ((x - xold)**2 + (y - yold)**2)**.5
        rad = self.getRad(0)
        time += dt
        while time < 1:
            x, y = self.getPos(time)
            alpha = self.getAlpha(time)
            ds = ((x - xold)**2 + (y - yold)**2)**.5
            rad = self.getRad(0)
            r, g, b = self.getRGB(time)
            drw.brush(x, y, r, g, b, rad, ds, alpha)
            if mirror:
                drw.brush(drw.getWidth() - x, y, r, g, b, rad, ds, alpha)

            time += dt
            xold, yold = x, y

    def copy(self):
        bz = BezierLine()
        bz._poscurve = self._poscurve.copy()
        bz._hcurve = self._hcurve.copy()
        bz._scurve = self._scurve.copy()
        bz._vcurve = self._vcurve.copy()
        bz._radcurve = self._radcurve.copy()
        bz._alphacurve = self._alphacurve.copy()
        return bz

    def randomize(self, positionmax=0, colormax=0, radiusmax=0, alphamax=0):
        self._poscurve.randomjostle(positionmax)
        self._hcurve.randomjostle(colormax)
        self._scurve.randomjostle(colormax)
        self._vcurve.randomjostle(colormax)
        self._radcurve.randomjostle(radiusmax)
        self._alphacurve.randomjostle(alphamax)

    def redistributePoints(self, n):
        self._poscurve.redistributePoints(n)
        self._hcurve.redistributePoints(n)
        self._scurve.redistributePoints(n)
        self._vcurve.redistributePoints(n)
        self._radcurve.redistributePoints(n)
        self._alphacurve.redistributePoints(n)
class BezierLine(object):

    def __init__(self):
        self._poscurve = Bezier([],[])
        self._hcurve = Bezier([],[])
        self._scurve = Bezier([],[])
        self._vcurve = Bezier([],[])
        self._radcurve = Bezier([],[])
        self._alphacurve = Bezier([],[])

    def setPos(self, xs, ys):
        self._poscurve = Bezier(xs,ys)

    def setHSV(self, hs, ss, vs):
        self._hcurve = Bezier(hs,[0]*len(hs))
        self._scurve = Bezier(ss,[0]*len(ss))
        self._vcurve = Bezier(vs,[0]*len(vs))

    def setRad(self, rads):
        self._radcurve = Bezier(rads,[0]*len(rads))

    def setAlpha(self, alpha):
        self._alphacurve = Bezier(alpha,[0]*len(alpha))

    def getPos(self, t):
        return self._poscurve(t)

    def getHSV(self, t):
        return self._hcurve(t)[0],self._scurve(t)[0],self._vcurve(t)[0]

    def getRGB(self, t):
        val = colorsys.hsv_to_rgb(self._hcurve(t)[0],self._scurve(t)[0],self._vcurve(t)[0])
        val2 = []
        for i in range(len(val)):
            val2 += [val[i]*256]
        return tuple(val2)

    def getRad(self, t):
        return self._radcurve(t)[0]

    def getAlpha(self, t):
        return self._alphacurve(t)[0]

    def draw(self, drw, mirror=True):
        time = 0
        dt = .005
        xold,yold = self.getPos(time)
        x,y = self.getPos(time +dt)
        ds = ((x-xold)**2 + (y-yold)**2)**.5
        rad = self.getRad(0)
        time += dt
        while time < 1:
            x,y = self.getPos(time)
            alpha = self.getAlpha(time)
            ds = ((x-xold)**2 + (y-yold)**2)**.5
            rad = self.getRad(0)
            r,g,b = self.getRGB(time)
            drw.brush(x,y, r,g,b, rad, ds,alpha)
            if mirror:
                drw.brush(drw.getWidth()-x, y, r,g,b,rad, ds, alpha)

            time += dt
            xold, yold = x, y

    def copy(self):
        bz = BezierLine()
        bz._poscurve = self._poscurve.copy()
        bz._hcurve = self._hcurve.copy()
        bz._scurve = self._scurve.copy()
        bz._vcurve = self._vcurve.copy()
        bz._radcurve = self._radcurve.copy()
        bz._alphacurve = self._alphacurve.copy()
        return bz

    def randomize(self, positionmax=0, colormax=0, radiusmax=0,alphamax=0):
        self._poscurve.randomjostle(positionmax)
        self._hcurve.randomjostle(colormax)
        self._scurve.randomjostle(colormax)
        self._vcurve.randomjostle(colormax)
        self._radcurve.randomjostle(radiusmax)
        self._alphacurve.randomjostle(alphamax)

    def redistributePoints(self, n):
        self._poscurve.redistributePoints(n)
        self._hcurve.redistributePoints(n)
        self._scurve.redistributePoints(n)
        self._vcurve.redistributePoints(n)
        self._radcurve.redistributePoints(n)
        self._alphacurve.redistributePoints(n)