def __init__(self, size=4):
self.size = size
self.score = 0
self.grid = [[Square(0)] * size for _ in range(size)]
tab = [Square(0)] * size * size
self.d = Display(size)
self.add_number()
while not lose(self.grid):
moved = False
while not moved:
self.d.print_grid(self.grid)
self.d.print_score(self.score)
self.dir = self.d.newDirection()
if self.dir == 0:
self.d.quit()
return
moved = self.move_number()
self.add_number()
for i in range(size):
for j in range(size):
tab[i + size * j] = self.grid[i][j]
if win(tab):
self.d.print_text("Tu as gagné !!!!!")
print("win")
print("Lose")
self.d.print_text("Tu as perdu !!!!!")
self.d.quit()
def test_output(self):
stdout = StdoutLogger()
message = "Welcome to Tic-Tac-Toe"
display = Display(stdout)
display.output(message)
assert stdout.log == f'{message}\n'
def __init__(self):
self.gymgate_repository = gymgate_repository.GymgateRepository()
self.is_running = True
self.RFID = RFID(bus=0, device=1)
self.display = Display()
self.servo = Servo(GPIO)
self.LED_green = LED(GPIO, 40)
self.LED_red = LED(GPIO, 12)
signal.signal(signal.SIGINT, self.close_program)
print("Gymgate scanner")
print("Press Ctrl-C to stop.")
self.start_program()
def test_display():
node_color = RED
d = Display(node_color)
result = d.display()
expected = [
[BLACK, BLACK, BLACK, BLACK, BLACK, BLACK, RED, RED],
[BLACK, BLACK, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, WHITE, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, BLACK, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, BLACK, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, BLACK, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, BLACK, WHITE, BLACK, BLACK, BLACK, RED, RED],
[BLACK, WHITE, WHITE, WHITE, BLACK, BLACK, RED, RED],
]
assert expected == result
def test_display_term_number():
"""
Terms occupy cols (0,4) and rows (1,7)
"""
node_color = RED
d = Display(node_color)
result = d._display_term()
expected = [
[BLACK, BLACK, WHITE, BLACK, BLACK],
[BLACK, WHITE, WHITE, BLACK, BLACK],
[BLACK, BLACK, WHITE, BLACK, BLACK],
[BLACK, BLACK, WHITE, BLACK, BLACK],
[BLACK, BLACK, WHITE, BLACK, BLACK],
[BLACK, BLACK, WHITE, BLACK, BLACK],
[BLACK, WHITE, WHITE, WHITE, BLACK],
]
assert result == expected
def test_display_follower_initial_state():
"""
Follower occupies pixels (6,7) (right - most 2 cols)
"""
node_color = RED
d = Display(node_color)
result = d._display_follower()
expected = [
[RED, RED],
[RED, RED],
[RED, RED],
[RED, RED],
[RED, RED],
[RED, RED],
[RED, RED],
[RED, RED],
]
assert expected == result
def __init__(self, size=4):
self.size = size
self.grid = [[Square(0)] * size for _ in range(size)]
tab = [Square(0)] * size * size
self.d = Display(size)
self.add_number()
while not lose(self.grid):
self.d.print_grid(self.grid)
moved = False
while not moved:
self.dir = new_direction()
if self.dir == 0:
quit()
return
moved = self.move_number()
self.add_number()
for i in range(self.size):
for j in range(self.size):
tab[i + self.size * j] = self.grid[i][j]
if win(tab):
print("win")
print("Lose")
quit()
def run_simulation(game_map: Map, Q: dict, epsilon_greedy=max_first):
display = Display(game_map)
game_map.reset()
state = deepcopy(game_map.get_init_state())
run = True
score = 0
display.render()
while run:
action = epsilon_greedy(Q, state,
game_map.get_available_actions(state), 0.3,
"softmax")
state, _ = game_map.apply_action(action)
run = not Display.is_close() and not game_map.is_final(score)
display.render()
Display.close_display()
if game_map.win():
print("Game Win!!!")
else:
print("Game Lose!!!")
def main():
'''
The main method of the application.
'''
whisk_display = Display()
# Start of app
whisk_display.print_general(WELCOME)
protocol = None
host = None
port = None
# Get the hostname, if it exists.
if len(sys.argv) > 2:
host = sys.argv[1]
# Get the portname, if it exists.
if len(sys.argv) > 3:
port = sys.argv[2]
rest_client = RestClient(protocol, host, port)
protocol, host, port = rest_client.get_protocol_host_port()
while True:
# Remind the user where the command is currently pointed at.
whisk_display.print_general("Using " + protocol + host + ":" + port + "/")
# Get the command.
command_to_use = retrieve_command(whisk_display).upper()
# Check which command this is for and run said command accordingly.
if (command_to_use == GET):
get_command(whisk_display, rest_client)
elif (command_to_use == POST):
post_command(whisk_display, rest_client)
elif (command_to_use == UPDATE):
update_command(whisk_display, rest_client)
elif (command_to_use == DELETE):
delete_command(whisk_display, rest_client)
elif (command_to_use == HELP):
help_command(whisk_display)
elif (command_to_use == EXIT):
break
def sarsa(game_map,
epsilon_greedy,
Q={},
learning_rate=0.1,
discovering_factor=0.9,
epsilon=0.3,
training_episode=1000,
evaluation_episode=10,
strategy="default",
verbose=False):
train_scores = []
eval_scores = []
initial_state = game_map.get_init_state()
win_game = 0
q_values = []
number_cell_visited = []
if verbose:
display = Display(game_map)
for train_ep in range(1, training_episode + 1):
game_map.reset()
score = 0
state = deepcopy(initial_state)
actions = game_map.get_available_actions_mouse()
action = epsilon_greedy(Q, state, actions, epsilon, strategy)
if verbose:
from src.map import ACTIONS
import sys
print_q(Q, game_map.height, game_map.width, ACTIONS)
display.render()
sys.stdin.readline()
if display.is_close():
sys.exit(0)
while not game_map.is_final(score):
# apply action and get the next state and the reward
next_state, reward = game_map.apply_action(action)
score += reward
state_q_value, number_visited = Q.get((state, action), (0, 0))
action_next_state = epsilon_greedy(
Q, next_state, game_map.get_available_actions(next_state),
epsilon, strategy)
next_state_q_value, _ = Q.get((next_state, action_next_state),
(0, 0))
q_value = state_q_value + learning_rate * (
reward + discovering_factor * next_state_q_value -
state_q_value)
Q[(state, action)] = (q_value, number_visited + 1)
state = next_state
action = action_next_state
if verbose:
from src.map import ACTIONS
import sys
print_q(Q, game_map.height, game_map.width, ACTIONS)
display.render()
sys.stdin.readline()
if display.is_close():
sys.exit(0)
q_values.append(sum([x[Q_VALUE] for x in Q.values()]))
win_game += int(game_map.win())
train_scores.append(score)
number_cell_visited.append(len(Q.keys()))
print("Episode {}/{}, score : {} win : {}".format(
train_ep, training_episode, score, game_map.win()))
if train_ep % evaluation_episode == 0:
avg_score = mean(train_scores[train_ep -
evaluation_episode:train_ep])
eval_scores.append(avg_score)
win_game /= training_episode
return Q, train_scores, eval_scores, win_game, q_values, number_cell_visited
from src.config import Config
from src.detect import Detect
from src.display import Display
from src.label import Label
from src.save import Save
from src.transform import Transform
from sys import argv
if len(argv) < 2:
print('You must specify a name argument.')
else:
config = Config().get()
capture = Capture(config)
trans = Transform(config)
display = Display()
detect = Detect()
label = Label()
with capture, display:
key = ''
while key != 'q':
success = False
image = capture.frame()
disk = trans.image_copy(image)
disk = trans.image_color_flip(disk)
small = trans.scale_image(image)
locs = detect.locations(small)
if len(locs) == 1:
success = True
loc = trans.scale_location(locs[0])
def __init__(self):
self.timer = None
self.viewIndex = 0 # defines which info will be displayed
self.weather = Weather()
self.display = Display()
self._setupButtons()
class ZerosegWeatherClock(object):
def __init__(self):
self.timer = None
self.viewIndex = 0 # defines which info will be displayed
self.weather = Weather()
self.display = Display()
self._setupButtons()
def _setupButtons(self):
GPIO.setmode(GPIO.BCM) # Use BCM GPIO numbers
GPIO.setup(SWITCH_1, GPIO.IN)
GPIO.setup(SWITCH_2, GPIO.IN)
def _resetViewIndex(self):
"""
Reset the viewIndex to 0 ( = time and date) and the timer to None.
"""
self.timer = None
self.viewIndex = 0
self.display.clear()
self.updateView(
) # call the updateView method directly so the changes are displayed immediately.
def _incrementViewIndex(self):
"""
Increment the viewIndex to switch to the next view.
"""
if self.timer is not None:
self.timer.cancel()
self.viewIndex += 1
self.viewIndex = self.viewIndex % VIEW_TOTAL_NUMBER # overflow
self.timer = threading.Timer(DEFAULT_VIEW_DISPLAY_TIME,
self._resetViewIndex)
self.timer.start()
self.display.clear()
self.updateView(
) # call the updateView method directly so the changes are displayed immediately.
def _updateDateTime(self):
self.display.writeDateAndTime(datetime.now())
def _updateTime(self):
self.display.writeTime(dateTimeObject=datetime.now())
def _updateDate(self):
self.display.writeDate(dateTimeObject=datetime.now())
def _updateTemperatureForecast(self):
temperature = self.weather.getForecastTemperature()
self.display.writeTemperatureLowHigh(tempLow=temperature.min,
tempHigh=temperature.max)
def _updateCurrentTemperature(self):
temperature = self.weather.getCurrentTemperature()
self.display.writeTemperatureCurrent(temp=temperature.current)
def updateView(self):
"""
Update the current view.
"""
# check the viewIndex and call the corresponding function
if self.viewIndex == VIEW_INDEX_TIME:
self._updateTime()
elif self.viewIndex == VIEW_INDEX_DATE:
self._updateDate()
elif self.viewIndex == VIEW_INDEX_TEMPERATURE_FORECAST:
self._updateTemperatureForecast()
elif self.viewIndex == VIEW_INDEX_TEMPERATURE_CURRENT:
self._updateCurrentTemperature()
def main(self):
while True:
try:
if not GPIO.input(SWITCH_1) or not GPIO.input(SWITCH_2):
self._incrementViewIndex()
self.updateView()
time.sleep(DEFAULT_UPDATE_INTERVAL)
except KeyboardInterrupt:
# self._incrementViewIndex()
# continue
self.display.clear()
raise
def display_sub():
stub_menu = Mock(Menu)
display_sub = Display(stub_menu)
yield display_sub
display_sub.clear()
#!/usr/bin/env python3
import sys
import pygame
import time
from src.display import Display
from src.player import Player
from genetic.genetic import Genetic
# Load classes.
pygame.init()
clock = pygame.time.Clock()
display = Display()
# Create a collection of players.
# Enable or disable genetic selection.
gen = Genetic(display.screen, display.size)
# Optional argument to allow playing.
if len(sys.argv) == 2:
if sys.argv[1] == 'play':
gen.toggle_training(False)
else:
gen.toggle_training(True)
if gen.training_enabled:
gen.init()
if gen.training_enabled:
players = gen.pool
else:
class GymGate:
def __init__(self):
self.gymgate_repository = gymgate_repository.GymgateRepository()
self.is_running = True
self.RFID = RFID(bus=0, device=1)
self.display = Display()
self.servo = Servo(GPIO)
self.LED_green = LED(GPIO, 40)
self.LED_red = LED(GPIO, 12)
signal.signal(signal.SIGINT, self.close_program)
print("Gymgate scanner")
print("Press Ctrl-C to stop.")
self.start_program()
def start_program(self):
while self.is_running:
self.LED_green.turn_off()
self.LED_red.turn_off()
self.display.show_message(u"\rWelkom!")
self.RFID.wait_for_tag()
(error, tag_type) = self.RFID.request()
if not error:
print("Tag detected")
(error, uid) = self.RFID.anticoll()
if not error:
print("UID: " + str(uid))
# Turn on the light
self.display.show_message(u"\rKaart gevonden")
card_uid = format_card_uid(uid)
print(card_uid)
user_data = self.gymgate_repository.get_user_status_by_card_uid(
card_uid)
user_id = user_data['user']['id']
if user_id is None:
self.LED_red.turn_on()
continue
self.LED_green.turn_on()
self.display.show_message(u"\rHallo " +
user_data['user']['voornaam'])
self.servo.rotate_open()
time.sleep(2)
if user_data['activeActiviteit'] is not None:
self.gymgate_repository.do_check_out(
user_id, AUTOMAAT[0]["id"], AUTOMAAT[0]["api_key"])
self.display.show_message(u"\rUitgecheckt")
else:
self.gymgate_repository.do_check_in(
user_id, AUTOMAAT[0]["id"], AUTOMAAT[0]["api_key"])
self.display.show_message(u"\rIngecheckt")
self.servo.rotate_close()
else:
self.show_error()
else:
self.show_error()
time.sleep(2)
def show_error(self):
self.LED_green.turn_off()
self.LED_red.turn_on()
self.display.show_message("Fout met pas")
def close_program(self, signal, frame):
print("Ctrl+C captured, ending read.")
self.is_running = False
self.RFID.cleanup()
self.display.close()
GPIO.cleanup()
sys.exit()
from src.capture import Capture
from src.config import Config
from src.detect import Detect
from src.display import Display
from src.encode import Encode
from src.label import Label
from src.transform import Transform
config = Config().get()
capture = Capture(config)
encode = Encode(config)
trans = Transform(config)
detect = Detect()
display = Display()
label = Label()
refs, ref_map = encode.images()
with capture, display:
while display.key() != 'q':
image = capture.frame()
label.set_image(image)
small = trans.scale_image(image)
locs, encs = detect.all(small)
for i in range(len(encs)):
lbl = False
enc = encs[i]
loc = locs[i]
cmps = detect.compare(refs, enc)
for j in range(len(cmps)):
import sys
import os
import math
path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
sys.path.insert(0, path)
from src.display import Display
from src.base import *
from src.colors import *
display = Display(size=(800, 800))
display.init_pygame()
og = Vector2D([0, 0])
point = Vector2D([1, 1])
a = Vector2D([2, 0])
b = Vector2D([0, 1])
c = a + b
matrix = Matrix2D([-1, 1,
0, 1])
degrees = math.pi/6 # 180/6 = 30
# matrix = Matrix2D([math.cos(degrees), -math.sin(degrees), math.sin(degrees), math.cos(degrees)])
i = 0
while display.running:
key = display.handle_events()
display.draw_point(og, COLOR_WHITE, 2)
display.draw_point(point, COLOR_CYAN, 5)
display.draw_line(og, a, COLOR_LRED)
if __name__ == '__main__':
# 添加oracle client驱动环境变量(添加到首位，避免与已存在client冲突)
os.environ['PATH'] = os.path.join(
os.path.dirname(os.path.realpath(sys.argv[0])),
'instantclient_19_3\\') + ';'
if os.getenv('TNS_ADMIN'):
del os.environ['TNS_ADMIN']
os.environ[
'NLS_LANG'] = 'SIMPLIFIED CHINESE_CHINA.AL32UTF8' # client使用utf-8编码
# 高DPI
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling,
True) # enable highdpi scaling
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps,
True) # use highdpi icons
app = QApplication(sys.argv)
# 加载QT 官方翻译
translator = QtCore.QTranslator()
translator.load("res/qt_zh_CN.qm")
QApplication.installTranslator(translator)
ui = mainUI.Ui_MainWindow()
# 可以理解成将创建的 ui 绑定到新建的 mainWnd 上
display = Display(ui)
display.show()
sys.exit(app.exec_())
def test_constructor():
this_nodes_color = RED
d = Display(this_nodes_color)
assert d.node_color == this_nodes_color
assert d.current_state == InitialState
class DeuxMilleQuaranteHuit:
def __init__(self, size=4):
self.size = size
self.grid = [[Square(0)] * size for _ in range(size)]
tab = [Square(0)] * size * size
self.d = Display(size)
self.add_number()
while not lose(self.grid):
self.d.print_grid(self.grid)
moved = False
while not moved:
self.dir = new_direction()
if self.dir == 0:
quit()
return
moved = self.move_number()
self.add_number()
for i in range(self.size):
for j in range(self.size):
tab[i + self.size * j] = self.grid[i][j]
if win(tab):
print("win")
print("Lose")
quit()
def add_number(self):
count = 0
for i in range(self.size):
for j in range(self.size):
if self.grid[i][j] == 0:
count += 1
if not count:
print("Lose")
quit()
number = randrange(count) + 1
for i in range(self.size):
for j in range(self.size):
if self.grid[i][j] == 0:
number -= 1
if number == 0:
self.grid[i][j] = Square(new_number())
def move_number(self):
has_moved = False
if self.dir % 2 == 0:
for i in range(1 if self.dir > 0 else self.size - 2,
self.size if self.dir > 0 else -1, self.dir // 2):
for j in range(self.size):
if self.grid[i][j] != 0:
k = i - self.dir // 2
move = True
while (k >= 0
if self.dir > 0 else k < self.size) and move:
if self.grid[k][j] != 0:
if self.grid[k][j].fusion or self.grid[i][
j].fusion or not is_fusion(
self.grid[k][j].value,
self.grid[i][j].value):
if k + self.dir // 2 != i:
has_moved = True
n = self.grid[i][j]
self.grid[i][j] = Square(0)
self.grid[k + self.dir // 2][j] = n
else:
has_moved = True
self.grid[k][j] = Square(
fusion(self.grid[i][j].value))
self.grid[k][j].fusion = True
self.grid[i][j] = Square(0)
move = False
elif k == 0 or k == self.size - 1:
has_moved = True
self.grid[k][j] = self.grid[i][j]
self.grid[i][j] = Square(0)
move = False
k -= self.dir // 2
else:
for j in range(1 if self.dir > 0 else self.size - 2,
self.size if self.dir > 0 else -1, self.dir):
for i in range(self.size):
if self.grid[i][j] != 0:
k = j - self.dir
move = True
while (k >= 0
if self.dir > 0 else k < self.size) and move:
if self.grid[i][k] != 0:
if self.grid[i][k].fusion or self.grid[i][
j].fusion or not is_fusion(
self.grid[i][k].value,
self.grid[i][j].value):
if k + self.dir != j:
has_moved = True
n = self.grid[i][j]
self.grid[i][j] = Square(0)
self.grid[i][k + self.dir] = n
else:
has_moved = True
self.grid[i][k] = Square(
fusion(self.grid[i][j].value))
self.grid[i][k].fusion = True
self.grid[i][j] = Square(0)
move = False
elif k == 0 or k == self.size - 1:
has_moved = True
self.grid[i][k] = self.grid[i][j]
self.grid[i][j] = Square(0)
move = False
k -= self.dir
for i in range(self.size):
for j in range(self.size):
self.grid[i][j].fusion = False
return has_moved
