def __init__(self, model_checkpoint, input_camera_device_id,
fake_camera_device):
self.tensor = ToTensor()
device = torch.device("cuda")
self.precision = torch.float16
model = torch.jit.load(model_checkpoint)
model.backbone_scale = 0.25
model.refine_mode = "sampling"
model.refine_sample_pixels = 80_000
self.model = model.to(device)
self.width, self.height = 1280, 720
w, h = int(self.width / 2), int(self.height / 2)
self.padding = [0, 0, w, h]
self.size = [h, w]
self.cam = Camera(device_id=input_camera_device_id,
width=self.width,
height=self.height)
fake_camera = pyfakewebcam.FakeWebcam(fake_camera_device, self.width,
self.height)
self.dsp = Displayer(fake_camera, w, h)
self.bgr = None
def main1():
world = World()
camera = Camera(Vec3(2, 1, 3), Vec3(0, 0, 0), Vec3(0, 0, 1), Vec3(0, 1, 0),
60, 400, 400)
sphereB = Sphere(Vec3(0, 0.5, 0), Vec3(0, 0, 0), 0.3, Vec3(0, 0, 255))
sphereR = Sphere(Vec3(0, 0, 1), Vec3(0, 0, 0), 0.3, Vec3(255, 0, 0))
sphereG = Sphere(Vec3(1, 0, 1), Vec3(0, 0, 0), 0.3, Vec3(0, 255, 0))
light1 = Light(Vec3(3, 2, 5), Vec3(0, 0, 0))
light2 = Light(Vec3(-2, 1, 1), Vec3(0, 0, 0))
world.add_camera(camera)
world.add_element(sphereB)
world.add_element(sphereR)
world.add_element(sphereG)
world.add_light(light1)
# world.add_light(light2)
r = Renderer(world)
picture = r.render(0)
d = Displayer()
d.display(picture)
def main():
img_reader = ImageReaderFactory().GenerateImageReader("./data/0000000000.png")
img_actor = ImageActor(img_reader.GetOutputPort())
displayer = Displayer(img_actor.actor)
displayer.Start()
def test_play_to_leaf_with_sims():
d = Deal(seed=0)
disp = Displayer()
dec = Decisions()
sim = Simulator()
e = GameEngine(disp, dec, sim)
sims = sim.load_sims(0)
d = e.play_to_leaf(d, sims, random=False)
assert_equal(d.full_history[0][1], d.trick_tally)
def test_play_to_all_leaves():
d = Deal(seed=0)
d.make_lead()
# print(d.original_hands)
disp = Displayer()
dec = Decisions()
sim = Simulator()
e = GameEngine(disp, dec, sim)
e.play_to_all_leaves(d)
assert_equal(d.trick_no, 5)
assert_equal(d.card_no, 17)
assert_equal(d.current_trick, [])
# we save this number from a previous run. Good to check we always traverse the whole tree
assert_equal(d.leaf_nodes, 832)
def test_find_all_layouts_and_run_sims():
deal = {
'N': set(['C14', 'C13', 'C12', 'C11']),
'E': set(['S14', 'S13', 'H12', 'H11']),
'S': set(['D14', 'D13', 'H14', 'H13']),
'W': set(['D12', 'D11', 'S12', 'S11'])
}
d = Deal(deal=deal)
sim = Simulator()
dec = Decisions()
disp = Displayer()
e = GameEngine(disp, dec, sim)
d.make_lead('D12')
layouts = sim.find_layouts(d)
# This should be the case because west has played a card already and north/south haven't
assert (len(layouts[2]) > len(layouts[0]))
def test_play_to_leaf():
deal = {
'N': set(['C14', 'C13', 'C12', 'C11']),
'E': set(['S14', 'S13', 'H12', 'H11']),
'S': set(['D14', 'D13', 'H14', 'H13']),
'W': set(['D12', 'D11', 'S12', 'S11'])
}
d = Deal(deal=deal)
disp = Displayer()
dec = Decisions()
sim = Simulator()
e = GameEngine(disp, dec, sim)
e.play_to_leaf(d)
assert_equal(d.trick_no, 5)
assert_equal(d.card_no, 17)
assert_equal(d.current_trick, [])
assert_equal(d.leaf_nodes, 1)
def test_generate_possible_layouts():
d = Deal(seed=0)
disp = Displayer()
dec = Decisions()
sim = Simulator()
e = GameEngine(disp, dec, sim)
layouts = sim.generate_layouts('NS',
set(['D12', 'D11', 'S12', 'S11']),
set(['C14', 'C13', 'C12', 'C11']),
d.all_cards,
lead=set([]))
assert_equal(len(layouts), scipy.special.comb(8, 4))
my_layout = {
'N': set(['C14', 'C13', 'C12', 'C11']),
'E': set(['S14', 'S13', 'H12', 'H11']),
'S': set(['D12', 'D11', 'S12', 'S11']),
'W': set(['D14', 'D13', 'H14', 'H13'])
}
def info(self, file_name, function_name, comments=""):
self.__logs.append(LogInfo(file_name, function_name, comments))
Displayer().showLogs(self.__logs, self.__login_level)
import randomwall
from displayer import Displayer
from ai import Ai
import time
import threading
import msvcrt
displayer = Displayer()
wall = randomwall.Wall()
ai = Ai()
radblock = randomwall.Radblock(ai.points)
beans = randomwall.Beans(ai.points, radblock.points2)
running = True
class InputThread(threading.Thread):
def __init__(self):
super().__init__()
def run(self):
global running
while running:
c = str(msvcrt.getch())
if c == "b'q'":
running = False
input_thread = InputThread()
input_thread.start()
count = 0
from displayer import Displayer
from wall import Wall
from snake import Snake
import time
import threading
from bug import Bug
import sys
displayer = Displayer() # 创建显示管理类对象
wall = Wall() # 创建墙的对象
snake = Snake() # 创建蛇的对象
bug = Bug(snake.points) # 创建虫子
running = True
class InputThread(threading.Thread):
def __init__(self):
super().__init__()
def run(self):
global running, snake # 引入声明在函数外的变量
while True: # sys.stdin.readline( ) sys.stdin.getch()
c = str(sys.stdin())
print(c)
if c == "b'q'":
running = False
elif c == "b'w'":
snake.set_toward("UP")
elif c == "b's'":
snake.set_toward("DOWN")
with open(
RES_ROOT_DIR +
f"{self.prefix}_dt_{self.time_step}_alpha_{self.alpha}_order_{self.order}_Bo_{self.bo}_DaI_{self.da}.csv",
"w") as f:
for z, u in enumerate(lastrun[::-1]):
f.write(f"{z*self.length_interval}, {u}" + "\n")
f.flush()
def get_savefile_path(self):
return RES_ROOT_DIR + f"{self.prefix}_dt_{self.time_step}_alpha_{self.alpha}_order_{self.order}_Bo_{self.bo}_DaI_{self.da}.csv"
if __name__ == '__main__':
from expdata import Result
from displayer import Displayer
sec = Solver(order=2,
dt=1e-2,
dz=1e-1,
alpha=1,
da=0.05,
bo=10,
totalTime=40,
note="testnorm")
sec.solve()
result = Result(sec.get_savefile_path())
# result2 = Result(RES_ROOT_DIR + "dt_0.0001_alpha_1_order_1_Bo_100_DaI_0.1.csv")
show = Displayer(0, 30, 0, 1)
show.plotmany([result])
show.save("testnorm.png")
show.show()
tao, psi = np.loadtxt(name, delimiter=",", usecols=(0, 1), unpack=True)
return tao, psi
def getLabel(self):
return f"Bo: {self.bo}"
def __str__(self) -> str:
return f"alpha_{self.alpha}_order_{self.order}_Bo_{self.bo}_DaI_{self.da}"
def getTruePsi(self):
if int(self.order) == 1:
return 1 / np.exp(float(self.da) * self.tao)
elif int(self.order) == 2:
return 1 / (1 + float(self.da) * self.tao)
else:
raise NotImplementedError
if __name__ == '__main__':
resname = [
"dt_0.0001_alpha_1_order_1_Bo_50_DaI_0.1",
"dt_0.0001_alpha_1_order_1_Bo_100_DaI_0.1",
"dt_0.0001_alpha_1_order_1_Bo_500_DaI_0.1",
"dt_0.0001_alpha_1_order_1_Bo_1000_DaI_0.1"
]
results = [Result(RES_ROOT_DIR + name + ".csv") for name in resname]
show = Displayer(0, 15, 0, 0.8)
show.plotmany(results)
show.save("compare_bo_1.png")
show.show()
from displayer import Displayer
print("\nHello. Welcome to the Basketball Leaderboard App.")
print("This app lets you enter the stats of as many players needed.")
print("Then, it will rank each player in every major statistical category.")
display_leaderboards = Displayer()
def main():
# SetMapperAndActor()
axes = vtkAxesActor()
displayer = Displayer(axes, style=vtkInteractorStyleTrackballCamera())
displayer.Start()
def get_all_logs(self):
Displayer().showLogs(self.__logs, self.__login_level)
def save_to_file(self, file_name):
Displayer().save_to_file(file_name, self.__login_level, self.__logs)
def __init__(self, url, interval):
self.fetcher = IndexFetcher(url)
self.displayer = Displayer()
self.interval = interval
