示例#1
0
文件: main.py 项目: ludehon/pyray
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)
示例#2
0
    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
示例#3
0
def main():
    img_reader = ImageReaderFactory().GenerateImageReader("./data/0000000000.png")

    img_actor = ImageActor(img_reader.GetOutputPort())

    displayer = Displayer(img_actor.actor)

    displayer.Start()
示例#4
0
 def __init__(self):
     Interface.__init__(self)
     Loader.__init__(self)
     Resizer.__init__(self)
     Processor.__init__(self)
     Colorizer.__init__(self)
     Displayer.__init__(self)
     
     getattr(self, self.args.command)()
示例#5
0
文件: app.py 项目: e0en/airpollution
class App(object):
    def __init__(self, url, interval):
        self.fetcher = IndexFetcher(url)
        self.displayer = Displayer()
        self.interval = interval

    def repeat_refreshing(self):
        self.fetcher.refresh()
        self.display()
        Timer(self.interval, self.repeat_refreshing).start()

    def display(self):
        if self.fetcher.status == Status.success:
            self.displayer.set_data(self.fetcher.data)

    def run(self):
        self.repeat_refreshing()
示例#6
0
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)
示例#7
0
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)
示例#8
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)
示例#9
0
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]))
示例#10
0
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'])
    }
示例#11
0
 def info(self, file_name, function_name, comments=""):
     self.__logs.append(LogInfo(file_name, function_name, comments))
     Displayer().showLogs(self.__logs, self.__login_level)
示例#12
0
from displayer import Displayer
from wall import Wall
from snake import Snake
from bug import Bug

import time
import threading
import msvcrt

displayer = Displayer()
wall = Wall()
snake = Snake()
bug = Bug(snake.points)

running = True


class InputThreading(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        global running, snake
        while running:
            c = str(msvcrt.getch())  # 输入读取,无需回车
            if c == "b'q'":
                running = False
            elif c == "b'w'":
                snake.set_toward("UP")
            elif c == "b's'":
                snake.set_toward("DOWN")
示例#13
0
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
示例#14
0
# 入口模块
from wall import Wall
from displayer import Displayer  # 前面是包名  后面是类名
from snake import Snake
import time
import threading
import msvcrt
from bug import Bug

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 running:
            c = str(msvcrt.getch())  # 输入读取  无需回车
            if c == "b'q'":
                running = False
            elif c == "b'w'":
                snake.set_toward("UP")
            elif c == "b's'":
                snake.set_toward("DOWN")
示例#15
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")
示例#16
0
文件: solver.py 项目: qwtsc/ADMfenics
        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()
示例#17
0
    "-p",
    "--password",
    dest="pw",
    help="Need the password to login user",
    default=None)

parser.add_option(
        "-n",
        "--number",
        dest="usernum",
        help="The user number to look up",
        type="int",
        default=2)

if not len(sys.argv) == 7:
    parser.print_help()
    sys.exit()

(options, args) = parser.parse_args()

test = RepReader(options.user,options.pw)
display = Displayer()

allrep = sorted(test.receivedrep(options.usernum),key=itemgetter(1),reverse=True)
display.displayAllRep(allrep)

print("\n")

mostrep = test.mostrepped(options.usernum)
display.displayMostRepped(mostrep)
示例#18
0
文件: app.py 项目: e0en/airpollution
 def __init__(self, url, interval):
     self.fetcher = IndexFetcher(url)
     self.displayer = Displayer()
     self.interval = interval
示例#19
0
class App:
    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 step(self, sct):
        if self.dsp.appMode == "normal":
            self.bgr = None
            frame = self.cam.read()
            frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
            self.dsp.step(frame)
        elif self.bgr == None:
            frame = self.cam.read()
            self.bgr = self.cv2_frame_to_cuda(frame)
        else:
            frame = self.cam.read()
            src = self.cv2_frame_to_cuda(frame)
            pha, fgr = self.model(src, self.bgr)[:2]

            tgt = torch.ones_like(fgr)

            if self.dsp.composeMode == "screen":
                tgt = self.cv2_frame_to_cuda(
                    np.array(sct.grab(sct.monitors[1])))
                tgt = TF.resize(tgt, [self.height, self.width])

            elif self.dsp.composeMode == "image" and self.dsp.imageFilename:
                tgt = cv2.imread(self.dsp.imageFilename)
                tgt = self.cv2_frame_to_cuda(tgt)
                tgt = TF.resize(tgt, [self.height, self.width])

            layer1 = TF.pad(TF.resize(pha * fgr, self.size), self.padding, 0)
            layer2 = TF.pad(TF.resize(1 - pha, self.size), self.padding, 1)

            if self.dsp.isFlipped:
                layer1 = TF.hflip(layer1)
                layer2 = TF.hflip(layer2)

            res = layer1 + layer2 * tgt
            res = res.mul(255).byte().cpu().permute(0, 2, 3, 1).numpy()[0]

            x, y, w, h = self.dsp.step(res)
            left, top, right, bottom = x, y, self.width - (
                x + w), self.height - (y + h)

            self.padding = [left, top, right, bottom]
            self.size = [h, w]

    def cv2_frame_to_cuda(self, frame):
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        return self.tensor(frame).unsqueeze_(0).cuda().to(self.precision)

    def run(self):
        with torch.no_grad():
            with mss.mss(display=":0.0") as sct:
                while self.dsp.isRunning:
                    self.step(sct)
示例#20
0
from wall import Wall
from wall import Radblock
from displayer import Displayer
from snake import Snake
from bug import Bug
import time
import threading
import msvcrt

displayer = Displayer()
wall = Wall()
snake = Snake()
radblock = Radblock()
bug = Bug(snake.points)

running = True


class InputThread(threading.Thread):
    def __init__(self):
        super().__init__()

    def run(self):
        global running, snake
        while running:
            c = str(msvcrt.getch())
            if c == "b'q'":
                running = False
            elif c == "b'w'":
                snake.set_toward("UP")
            elif c == "b's'":
示例#21
0
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()

示例#22
0
import tkinter
import option
import time
import randomwall
from displayer import Displayer
from ai import Ai
import threading
import player

# 创建所有对象
displayer = Displayer()
wall = randomwall.Wall()
ai = Ai()
player = player.Player()
radblock = randomwall.Radblock(ai.points, player.points)
beans = randomwall.Beans(ai.points, radblock.points2, player.points)
# player方向
fangxiang = "xia"
# 创建一把锁
lock = threading.Lock()

# 打开一个窗口
window = tkinter.Tk()
# 设置标题
window.title("吃豆大战")
# 设置大小
size = str(option.size_x * 23) + 'x' + str(option.size_y * 25 + 50)
window.geometry(size)
# 在图形界面上创建画布并放置各种元素
canvas = tkinter.Canvas(window, bg='white', height=option.size_x * 20 + 1, width=option.size_y * 20 + 1)
示例#23
0
 def get_all_logs(self):
     Displayer().showLogs(self.__logs, self.__login_level)
示例#24
0
        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()
示例#25
0
 def save_to_file(self, file_name):
     Displayer().save_to_file(file_name, self.__login_level, self.__logs)
示例#26
0
def main():
    # SetMapperAndActor()
    axes = vtkAxesActor()
    displayer = Displayer(axes, style=vtkInteractorStyleTrackballCamera())

    displayer.Start()