示例#1
0
 def CalcUpdatePeriod(self, speed):
     """
     # returns an update period for this wave based on speed
     # speed is based on magnitude at time of spawn / max magnitude
     # speed = 1.0 is fastest. speed = 0.0 is slowest
     """
     speed = clamp(0,speed,1.0)
     self.update_period = (updateSpeed_max - (pytweening.linear(speed) * (updateSpeed_max-updateSpeed_min)))
示例#2
0
def blinks(gray, face):
    status = ''
    rect = face
    if rect is not None:

        # determine the facial landmarks for the face region, then
        # convert the facial landmark (x, y)-coordinates to a NumPy
        # array
        shape = predictor(gray, rect)
        shape = face_utils.shape_to_np(shape)
        #leftEye ,rightEye = leftEye_rightEye

        # extract the left and right eye coordinates, then use the
        # coordinates to compute the eye aspect ratio for both eyes
        leftEye = shape[lStart:lEnd]
        rightEye = shape[rStart:rEnd]
        leftEAR = eye_aspect_ratio(leftEye)
        rightEAR = eye_aspect_ratio(rightEye)
        # average the eye aspect ratio together for both eyes
        ear = (leftEAR + rightEAR) / 2.0

        if ear < EYE_AR_THRESH:
            status = 'closed_eye'
            pyautogui.doubleClick()
            pytweening.linear(0.75)
            ######### this code to determine x,y
            x, y = pyautogui.position()
            positionStr = 'X: ' + str(x).rjust(4) + ' Y: ' + str(y).rjust(4)
            print(positionStr, 'end')
            print('\b' * len(positionStr), 'end')

        # otherwise, the eye aspect ratio is not below the blink
        # threshold
        else:
            status = 'open_eye'

    # show the frame
    return status
示例#3
0
def make_frame(t):
    #colorDiv = t + 0.01
    #color1= [1.0 / colorDiv, 0.0, 0.0]
    #color2 = [0.0, 1.0 / colorDiv, 0.0]

    #gradient= gizeh.ColorGradient("linear",((0,(0,.5,1)),(1,(0,1,1))), xy1=(-cosR,-sinR), xy2=(cosR,sinR))

    #gradRad1 = radius1 - 20
    #gradRad2 = radius1 + 20
    #gradient = gizeh.ColorGradient(type="radial",
    #                               stops_colors = [(0,color1),(1,color2)],
    #                               xy1=[0.0,0.0], xy2=[gradRad1,0.0], xy3 = [0.0,gradRad2])
    surface = gizeh.Surface(W,H)

    # orbit halo
    #circle1 = gizeh.circle(radius1, xy = (W/2, H/2), stroke=gradient, stroke_width=5)
    #circle1.draw(surface)

    for i in range(numParticles):
      # Orbiting planet
      particle = particles[i]

      if (particle.easing == 1):
        angle = pytweening.linear((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 2):
        angle = pytweening.easeInQuad((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 3):
        angle = pytweening.easeOutQuad((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 4):
        angle = pytweening.easeInOutQuad((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 5):
        angle = pytweening.easeInSine((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 6):
        angle = pytweening.easeOutSine((duration - t) / duration) * 360 * particle.direction
      elif (particle.easing == 7):
        angle = pytweening.easeInOutSine((duration - t) / duration) * 360 * particle.direction
      radians = math.radians(angle)
      cosR = math.cos(radians)
      sinR = math.sin(radians)
      x = W/2 + cosR * particle.orbit_radius
      y = H/2 + sinR * particle.orbit_radius
      fill = particle.color
      #circle = gizeh.circle(particle.radius, xy = (x, y), fill=(1,0,1))
      circle = gizeh.circle(particle.radius, xy = (x, y), fill=fill)
      circle.draw(surface)

    return surface.get_npimage()
示例#4
0
    def loop(self):
        while True:
            t = time.time()
            passed = t - self.tickTime
            self.tickTime = t
            conf = self.conf
            conf.processScan()  # See if WoW is running or not

            if self.saveScheduled:
                self.saveScheduled = 0
                self.conf.saveConfig()

            if self.sock.connected and self.conf.wowPid:

                color = conf.updatePixelColor()
                if conf.g == 51:
                    index = 0
                    hpp = conf.r / 255
                    if hpp < self.cacheHP:
                        self.startTween(
                            (self.cacheHP - hpp) * self.conf.hpRatio)
                    self.cacheHP = hpp
            if self.tweenStarted:
                tweenPerc = 1 - (t - self.tweenStarted) / self.tweenDuration
                if tweenPerc < 0:
                    tweenPerc = 0
                    self.tweenStarted = 0
                elif tweenPerc > 1:
                    tweenPerc = 1
                self.tweenVal = pytweening.linear(tweenPerc) * self.tweenStart

            if not self.conf.wowPid:
                time.sleep(1)
            else:
                after = time.time()
                logicTime = 1 / self.FRAMERATE - (after - t)
                if logicTime > 0:
                    time.sleep(logicTime)
示例#5
0
        ########Mouse Drags
        #pyautogui.dragTo(100, 200, button='left')     # drag mouse to X of 100, Y of 200 while holding down left mouse button
        #pyautogui.dragTo(300, 400, 2, button='left')  # drag mouse to X of 300, Y of 400 over 2 seconds while holding down left mouse button
        #########Tween / Easing Functions
        #pyautogui.moveTo(100, 100, 2, pyautogui.easeInQuad)     # start slow, end fast
        #pyautogui.moveTo(100, 100, 2, pyautogui.easeInOutQuad)  # start and end fast, slow in middle
        #######Mouse Clicks
        #pyautogui.click()  # click the mouse
        #pyautogui.click(x=100, y=200)  # move to 100, 200, then click the left mouse button.
        #pyautogui.click(button='right')  # right-click the mouse
        #pyautogui.click(clicks=2)  # double-click the left mouse button
        #pyautogui.click(clicks=2, interval=0.25)  # double-click the left mouse button, but with a quarter second pause in between clicks
        #pyautogui.click(button='right', clicks=3, interval=0.25)  ## triple-click the right mouse button with a quarter second pause in between clicks
        #pyautogui.doubleClick()  # perform a left-button double click
        #pyautogui.tripleClick()
        ##########The mouseDown() and mouseUp() Functions
        #pyautogui.mouseDown(); pyautogui.mouseUp()  # does the same thing as a left-button mouse click
        #pyautogui.mouseDown(button='right')  # press the right button down
        #pyautogui.mouseUp(button='right', x=100, y=200)  # move the mouse to 100, 200, then release the right button up.
        ##########Mouse Scrolling
        # pyautogui.scroll(10)   # scroll up 10 "clicks"
        #pyautogui.hscroll(-10)   # scroll left 10 "clicks"
        pytweening.linear(0.75)
        ######### this code to determine x,y
        x, y = pyautogui.position()
        positionStr = 'X: ' + str(x).rjust(4) + ' Y: ' + str(y).rjust(4)
        print(positionStr, end='')
        print('\b' * len(positionStr), end='', flush=True)
except KeyboardInterrupt:
    print('\n')
          ('Quart', pytweening.easeInQuart, pytweening.easeOutQuart, pytweening.easeInOutQuart),
          ('Quint', pytweening.easeInQuint, pytweening.easeOutQuint, pytweening.easeInOutQuint),
          ('Sine', pytweening.easeInSine, pytweening.easeOutSine, pytweening.easeInOutSine),
          ('Expo', pytweening.easeInExpo, pytweening.easeOutExpo, pytweening.easeInOutExpo),
          ('Circ', pytweening.easeInCirc, pytweening.easeOutCirc, pytweening.easeInOutCirc),
          ('Elastic', pytweening.easeInElastic, pytweening.easeOutElastic, pytweening.easeInOutElastic),
          ('Back', pytweening.easeInBack, pytweening.easeOutBack, pytweening.easeInOutBack),
          ('Bounce', pytweening.easeInBounce, pytweening.easeOutBounce, pytweening.easeInOutBounce),
         )

# Linear function has only a single function, not three.
wb.create_sheet(title='Linear')
sheet = wb.get_sheet_by_name('Linear')
for i in range(1, 101):
    n = i / 100.0
    sheet['A' + str(i)] = pytweening.linear(n)

    if MAKE_CHARTS:
        refObj = openpyxl.charts.Reference(sheet, (1, 1), (100, 1))
        seriesObj = openpyxl.charts.Series(refObj, title='Linear')
        chartObj = openpyxl.charts.LineChart()
        chartObj.append(seriesObj)
        chartObj.drawing.top = 50
        chartObj.drawing.left = 300
        chartObj.drawing.width = 300
        chartObj.drawing.height = 200
        sheet.add_chart(chartObj)


for graph in graphs:
    name, easeInFunc, easeOutFunc, easeInOutFunc = graph
示例#7
0
 def liner(n):
     """ 速度均匀 """
     return pytweening.linear(n)
示例#8
0
def run_pattern(df,
                target,
                iters=100000,
                num_frames=100,
                decimals=2,
                shake=0.2,
                max_temp=0.4,
                min_temp=0,
                ramp_in=False,
                ramp_out=False,
                freeze_for=0,
                labels=["X Mean", "Y Mean", "X SD", "Y SD", "Corr."],
                reset_counts=False,
                custom_points=False):

    global frame_count
    global it_count

    if reset_counts:
        it_count = 0
        frame_count = 0

    r_good = df.copy()

    # this is a list of frames that we will end up writing to file
    write_frames = [
        int(round(pytweening.linear(x) * iters))
        for x in np.arange(0, 1, 1 / (num_frames - freeze_for))
    ]

    if ramp_in and not ramp_out:
        write_frames = [
            int(round(pytweening.easeInSine(x) * iters))
            for x in np.arange(0, 1, 1 / (num_frames - freeze_for))
        ]
    elif ramp_out and not ramp_in:
        write_frames = [
            int(round(pytweening.easeOutSine(x) * iters))
            for x in np.arange(0, 1, 1 / (num_frames - freeze_for))
        ]
    elif ramp_out and ramp_in:
        write_frames = [
            int(round(pytweening.easeInOutSine(x) * iters))
            for x in np.arange(0, 1, 1 / (num_frames - freeze_for))
        ]

    extras = [iters] * freeze_for
    write_frames.extend(extras)

    # this gets us the nice progress bars in the notbook, but keeps it from crashing
    looper = trange
    if is_kernel():
        looper = tnrange

    # this is the main loop, were we run for many iterations to come up with the pattern
    for i in looper(iters + 1,
                    leave=True,
                    ascii=True,
                    desc=target + " pattern"):
        t = (max_temp - min_temp) * s_curve(((iters - i) / iters)) + min_temp

        if target in all_targets:
            test_good = perturb(r_good.copy(),
                                initial=df,
                                target=target,
                                temp=t)
        else:
            raise Exception("bah, that's not a proper type of pattern")

        # here we are checking that after the purturbation, that the statistics are still within the allowable bounds
        if is_error_still_ok(df, test_good, decimals):
            r_good = test_good

        # save this chart to the file
        for x in xrange(write_frames.count(i)):
            save_scatter_and_results(r_good,
                                     target + "-image-" +
                                     format(int(frame_count), '05'),
                                     150,
                                     labels=labels)
            #save_scatter(r_good, target + "-image-"+format(int(frame_count), '05'), 150)
            r_good.to_csv(target + "-data-" + format(int(frame_count), '05') +
                          ".csv")

            frame_count = frame_count + 1
    return r_good
示例#9
0
 def update(self, dt):
     self.rect.x = 750 * tween.linear(self.iter / ITERATIONS)
     self.rect.y = 10 + 550 * func(self.iter / ITERATIONS)
     self.iter += 1
     if self.iter > ITERATIONS:
         self.iter = 0
示例#10
0
 def update(self, dt):
     self.rect.x = 750 * tween.linear(self.iter / ITERATIONS)
     self.rect.y = 10 + 550 * func(self.iter / ITERATIONS)
     self.iter += 1
     if self.iter > ITERATIONS:
         self.iter = 0
示例#11
0
    ('Circ', pytweening.easeInCirc, pytweening.easeOutCirc,
     pytweening.easeInOutCirc),
    ('Elastic', pytweening.easeInElastic, pytweening.easeOutElastic,
     pytweening.easeInOutElastic),
    ('Back', pytweening.easeInBack, pytweening.easeOutBack,
     pytweening.easeInOutBack),
    ('Bounce', pytweening.easeInBounce, pytweening.easeOutBounce,
     pytweening.easeInOutBounce),
)

# Linear function has only a single function, not three.
wb.create_sheet(title='Linear')
sheet = wb.get_sheet_by_name('Linear')
for i in range(1, 101):
    n = i / 100.0
    sheet['A' + str(i)] = pytweening.linear(n)

    if MAKE_CHARTS:
        refObj = openpyxl.charts.Reference(sheet, (1, 1), (100, 1))
        seriesObj = openpyxl.charts.Series(refObj, title='Linear')
        chartObj = openpyxl.charts.LineChart()
        chartObj.append(seriesObj)
        chartObj.drawing.top = 50
        chartObj.drawing.left = 300
        chartObj.drawing.width = 300
        chartObj.drawing.height = 200
        sheet.add_chart(chartObj)

for graph in graphs:
    name, easeInFunc, easeOutFunc, easeInOutFunc = graph
    wb.create_sheet(title=name)