def startGame(self):
if len(self.players) == 1:
self.players.append('computer')
self.game = plane(len(self.players))
ran = self.game.rollRan()
img = [self.game.createFrame()]
return img, '游戏开始，玩家列表:\n' + self.getPlayers() + '下一玩家:%s\n下一点数:%d' % (self.players[0], ran)
def _compute_plane(self):
p0 = point.point(self._p1[0], self._p1[1], self._p1[2])
p1 = point.point(self._p2[0], self._p2[1], self._p2[2])
p2 = point.point(self._p3[0], self._p3[1], self._p3[2])
self._down_plane = plane.plane(p0, p1, p2)
p4 = point.point(self._p5[0], self._p5[1], self._p5[2])
p6 = point.point(self._p7[0], self._p7[1], self._p7[2])
p7 = point.point(self._p8[0], self._p8[1], self._p8[2])
self._up_plane = plane.plane(p4, p6, p7)
p0 = point.point(self._p1[0], self._p1[1], self._p1[2])
p1 = point.point(self._p2[0], self._p2[1], self._p2[2])
p5 = point.point(self._p6[0], self._p6[1], self._p6[2])
self._left_plane = plane.plane(p0, p1, p5)
p3 = point.point(self._p4[0], self._p4[1], self._p4[2])
p6 = point.point(self._p7[0], self._p7[1], self._p7[2])
p7 = point.point(self._p8[0], self._p8[1], self._p8[2])
self._right_plane = plane.plane(p3, p6, p7)
p1 = point.point(self._p2[0], self._p2[1], self._p2[2])
p2 = point.point(self._p3[0], self._p3[1], self._p3[2])
p6 = point.point(self._p7[0], self._p7[1], self._p7[2])
self._back_plane = plane.plane(p1, p2, p6)
p0 = point.point(self._p1[0], self._p1[1], self._p1[2])
p3 = point.point(self._p4[0], self._p4[1], self._p4[2])
p7 = point.point(self._p8[0], self._p8[1], self._p8[2])
self._front_plane = plane.plane(p0, p3, p7)
def step_impl(context):
context.shape = plane()
D = 25.2
DEPTH_EPS = -1.0
R_HOLE = 8.92
D_HOLE = 4.4
D_INNER = 12.0
PLANE_XY = D + mat['tool_size']
# origin is at the center of the part
g = G(outfile='path.nc', aerotech_include=False, header=None, footer=None)
nomad_header(g, mat, CNC_TRAVEL_Z)
g.absolute()
g.move(z=0)
plane(g, mat, PLANE_DEPTH, -PLANE_XY / 2, -PLANE_XY / 2, PLANE_XY / 2,
PLANE_XY / 2)
g.move(x=0, y=0)
g.move(z=-PLANE_DEPTH)
for r in range(6):
theta = r * math.pi * 2.0 / 6.0
x = math.cos(theta) * R_HOLE
y = math.sin(theta) * R_HOLE
g.move(z=PLANE_DEPTH + 1.0)
g.move(x=x, y=y)
g.move(z=PLANE_DEPTH)
hole(g, mat, -H + DEPTH_EPS, d=D_HOLE)
g.move(z=PLANE_DEPTH + 1.0)
def step_impl(context):
context.upper = plane()
context.upper.material.reflective = 1
context.upper.material.transform = translation(0, 1, 0)
from canvas import canvas_to_ppm
from material import material
from matrix import scaling, translation, view_transform
from plane import plane
from sphere import sphere
from tuple import color, point, point_light, vector
from world import world
if __name__ == "__main__":
start = time.time()
print("Starting render...")
w = world()
w.light = point_light(point(-10, 10, -10), color(1, 1, 1))
floor = plane()
floor.transform = scaling(10, 0.01, 10)
floor.material.color = color(1, 0.9, 0.9)
floor.material.specular = 0
w.objects.append(floor)
# left_wall = sphere()
# left_wall.transform = translation(0, 0, 5) * rotation_y(-pi/4) * rotation_x(pi/2) * scaling(10, 0.01, 10)
# left_wall.material = floor.material
# w.objects.append(left_wall)
# right_wall = sphere()
# right_wall.transform = translation(0, 0, 5) * rotation_y(pi/4) * rotation_x(pi/2) * scaling(10, 0.01, 10)
# right_wall.material = floor.material
# w.objects.append(right_wall)
from plane import plane
from sphere import sphere
from tuple import color, point, point_light, vector
from world import world
if __name__ == "__main__":
start = time.time()
print("Starting render...")
w = world()
w.light = point_light(point(-10, 10, -10), color(1, 1, 1))
black = color(0, 0, 0)
white = color(1, 1, 1)
floor = plane()
floor.transform = scaling(0.5, 0.5, 0.5)
floor.material.color = color(0.9, 0.9, 0.9)
floor.material.specular = 0.3
floor.material.pattern = checkers_pattern(black, white)
floor.material.reflective = 0.6
w.objects.append(floor)
left_wall = plane()
left_wall.transform = (translation(0, 0, 5) * rotation_y(-pi / 4) *
rotation_x(pi / 2) * scaling(10, 0.01, 10))
left_wall.material.specular = 0.7
left_wall.material.pattern = stripe_pattern(black, white)
w.objects.append(left_wall)
right_wall = plane()
# -*- coding: utf-8 -*-
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import sphere
import camera
import plane
import sys
window = 0
sph = sphere.sphere(16, 16, 1)
camera = camera.camera()
plane = plane.plane(12, 12, 1., 1.)
def InitGL(width, height):
glClearColor(0.1, 0.1, 0.5, 0.1)
glClearDepth(1.0)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45.0, float(width) / float(height), 0.1, 100.0)
camera.move(0.0, 3.0, -5)
def DrawGLScene():
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glMatrixMode(GL_MODELVIEW)
camera.setLookat()
plane.draw()
import random; from plane import plane; from functions import *
#Added a functional waiting list,
hamilton = plane(500, 0, 20)
bahamas = plane(1000, -20, 5)
moscow = plane(1700, -5, 10)
print "HAMILTON FLIGHT SEATS:" + str(hamilton.seats) + "\nBAHAMAS FLIGHT SEATS:" + str(bahamas.seats) + "\nMOSCOW FLIGHT SEATS: " + str(moscow.seats)
choice = 0
notdone = True
print "Welcome to Toronto International Airport!"
while notdone:
choice = choose("\n1. Book a flight\n2. Cancel a flight\n3. File a complaint\n4. Exit\n")
if choice == 1:
choice = choose("Book a flight to...\n1. Hamilton\n2. The Bahamas\n3. Moscow\n")
if choice == 1:
booking(hamilton)
elif choice == 2:
booking(bahamas)
elif choice == 3:
booking(moscow)
if choice == 2:
choice = choose("Cancel which flight?\n1. Hamilton\n2. The Bahamas\n3. Moscow\n")
if choice == 1:
if hamilton.booked: hamilton.cancel()
elif choice == 2:
if bahamas.booked: bahamas.cancel()
elif choice == 3:
if moscow.booked: moscow.cancel()
if choice == 3:
import sys
sys.path.append("../modules")
import plane
import point
import math
p1 = point.point(0.060167, -0.267595, -0.094069)
p2 = point.point(-0.029163, -0.510884, 1.967362)
p3 = point.point(-1.836883, 0.380311, 0.286389)
pA = plane.plane(p1, p2, p3)
p4 = point.point(0.060167, -0.267595, -0.094069)
p5 = point.point(2.036123, -0.514122, 0.052635)
p6 = point.point(-0.129902, -0.189737, -1.927521)
pB = plane.plane(p4, p5, p6)
angle = pA.return_angle(pB)
print angle, "rad ", 360.0 * (angle / math.pi), " grad"
trfCmplxFile = os.path.join(nuSIMPATH, '11-Parameters/nuSTORM-TrfLineCmplx-Params-v1.0.csv')
print ("ftrfCmplxFile " , trfCmplxFile)
print ("numSIMPATH, filename, rootfilename, trfCmplxFile \n", nuSIMPATH, "\n", filename, "\n", rootFilename,
"\n", trfCmplxFile)
outFilename = rootFilename
logging.info("Parameters: %s, \ntransfer line parameters: %s, \noutput file: %s", filename, trfCmplxFile, rootFilename)
# Get machine and run parameters
nuStrt = nuPrdStrt.nuSTORMPrdStrght(filename)
psLength = nuStrt.ProdStrghtLen()
nuTrLnCmplx = nuTrfLineCmplx.nuSTORMTrfLineCmplx(trfCmplxFile)
tlCmplxLength = nuTrLnCmplx.TrfLineCmplxLen()
detectorPosZ = nuStrt.HallWallDist()
# set up the detector front face
fluxPlane = plane.plane(psLength, detectorPosZ)
# set up the event history - instantiate
eH = eventHistory.eventHistory()
eH.outFile(outFilename)
# create the root structure to write to
eH.rootStructure()
# initialise the python arrays to something sensible
eH.makeHistory()
# event loop
for event in range(nEvents):
# generate a pion
pi = piEvtInst.PionEventInstance(pionMom)
# set its values
s = 0.0
xl = 0.0
class running:
'''Class to be passed into both threaded functions so they can communicate when to end mid-thread'''
def __init__(self):
self.running = False
if __name__ == '__main__':
width = 1020
height = 1020
num_lines = 30
depth = 400
left_coordinates = create_coordinates('left', width, height, num_lines, depth)
right_coordinates = create_coordinates('right', width, height, num_lines, depth)
top_coordinates = create_coordinates('top', width, height, num_lines, depth)
bottom_coordinates = create_coordinates('bottom', width, height, num_lines, depth)
play = player(510, 925)
map1 = plane(1, play, (0, 125, 125))
map2 = plane(2, play, (0, 125, 125))
map3 = plane(3, play, (125, 0, 125))
map4 = plane(4, play, (125, 0, 125))
map1.populate(10000, num_lines, 6)
map2.populate(10000, num_lines, 6)
map3.populate(10000, num_lines, 6)
map4.populate(10000, num_lines, 6)
r = running()
try:
faceThread = threading.Thread(target = read_frame, name = 'face', args = (r,))
gameThread = threading.Thread(target = update, name = 'game', args = (left_coordinates, right_coordinates, bottom_coordinates, top_coordinates, map1, map2, map3, map4, play, num_lines, faceThread, r))
gameThread.start()
r.running = True
faceThread.start()
gameThread.join()
import random
from plane import plane
from environment import environment
import logging
import time
if __name__ == "__main__":
flying_machine1 = plane(0.9,"Boening 404")
flying_machine2 = plane(0.5,"Unit Under Test 1")
flying_machine3 = plane(0.0,"No Need Of Correction Plane")
planes_under_test = [flying_machine1, flying_machine2, flying_machine3]
period = 0.1
time_stamps = 2000
test_environment = environment(period,planes_under_test)
file_logger = logging.getLogger("Data Logger")
logging.basicConfig(filename='data.log',filemode='w', level=logging.INFO)
print("Starting simulation\n")
print("Logging simulation data, please wait...")
env_info=[]
for i in range(time_stamps):
def step_impl(context):
context.floor2 = plane()
context.floor2.transform = translation(0, -1, 0)
context.floor2.material.reflective = 0.5
context.floor2.material.transparency = 0.5
context.floor2.material.refractive_index = 1.5
zlist2 = zlist[len(zlist) / 2:]
atoms2 = atoms[len(atoms) / 2:]
if len(nanaparticles) != 2:
print "Only two nanoparticles can be used"
exit(1)
DITS1 = 2.6
DIST2 = 12.6
nanop1 = nanaparticles[0]
ptop, pbot = nanop1.get_ptop_and_bottom()
l1 = line.line3d()
l1.set_two_point(ptop, pbot)
p1, p2, p3, p4 = nanop1.get_middle_points()
mdplane = plane.plane(p1, p2, p3)
group1_np1 = []
group2_np1 = []
group3_np1 = []
allnp1 = []
for i in range(len(xlist1)):
p = point.point(xlist1[i], ylist1[i], zlist1[i])
dist = mdplane.get_distance(p) * mdplane.check_point_side(p)
if dist < DITS1:
group1_np1.append((p.get_x(), p.get_y(), p.get_z()))
elif dist >= DITS1 and dist < DIST2:
group2_np1.append((p.get_x(), p.get_y(), p.get_z()))
else:
def project_point_101(self, pp):
dist = float("inf")
pret = point.point()
peqn = plane.plane()
p = self._UP_pright.project_point(pp)
if (self.__is_in_polyhedra(0, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._UP_pright
p = self._UP_pback.project_point(pp)
if (self.__is_in_polyhedra(1, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._UP_pback
p = self._UP_pleft.project_point(pp)
if (self.__is_in_polyhedra(2, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._UP_pleft
p = self._UP_pfront.project_point(pp)
if (self.__is_in_polyhedra(3, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._UP_pfront
p = self._DOWN_pright.project_point(pp)
if (self.__is_in_polyhedra(5, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._DOWN_pright
p = self._DOWN_pback.project_point(pp)
if (self.__is_in_polyhedra(6, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._DOWN_pback
p = self._DOWN_pleft.project_point(pp)
if (self.__is_in_polyhedra(7, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._DOWN_pleft
p = self._DOWN_pfront.project_point(pp)
if (self.__is_in_polyhedra(8, p)):
d = p.get_distance_from(pp)
if (d < dist):
dist = d
pret = p
peqn = self._DOWN_pfront
return pret, peqn
def __compute_plane(self):
# forse mi perdo i punti in superficie
# molto liberamente ispirato a questo:
# http://www.gamedev.net/topic/593430-finding-out-whether-a-point-is-in-a-frustum/
# calcolo qui i piani che uso poi
h1_p1 = point.point(self._x[0][0], self._x[0][1], self._x[0][2])
h1_p2 = point.point(self._x[1][0], self._x[1][1], self._x[1][2])
h1_p3 = point.point(self._x[2][0], self._x[2][1], self._x[2][2])
h1_p4 = point.point(self._x[3][0], self._x[3][1], self._x[3][2])
h1_p5 = point.point(self._x[4][0], self._x[4][1], self._x[4][2])
h1_p6 = point.point(self._x[5][0], self._x[5][1], self._x[5][2])
h1_p7 = point.point(self._x[6][0], self._x[6][1], self._x[6][2])
h1_p8 = point.point(self._x[7][0], self._x[7][1], self._x[7][2])
self._UP_pright = plane.plane(h1_p1, h1_p2, h1_p5)
self._UP_pleft = plane.plane(h1_p3, h1_p4, h1_p8)
self._UP_pbottom = plane.plane(h1_p1, h1_p2, h1_p3)
self._UP_ptop = plane.plane(h1_p8, h1_p5, h1_p6)
self._UP_pback = plane.plane(h1_p2, h1_p4, h1_p8)
self._UP_pfront = plane.plane(h1_p1, h1_p3, h1_p5)
h2_p1 = point.point(self._x[0][0], self._x[0][1], self._x[0][2])
h2_p2 = point.point(self._x[1][0], self._x[1][1], self._x[1][2])
h2_p3 = point.point(self._x[2][0], self._x[2][1], self._x[2][2])
h2_p4 = point.point(self._x[3][0], self._x[3][1], self._x[3][2])
h2_p5 = point.point(self._x[8][0], self._x[8][1], self._x[8][2])
h2_p6 = point.point(self._x[9][0], self._x[9][1], self._x[9][2])
h2_p7 = point.point(self._x[10][0], self._x[10][1], self._x[10][2])
h2_p8 = point.point(self._x[11][0], self._x[11][1], self._x[11][2])
self._DOWN_pright = plane.plane(h2_p1, h2_p2, h2_p6)
self._DOWN_pleft = plane.plane(h2_p7, h2_p3, h2_p8)
self._DOWN_pbottom = plane.plane(h2_p5, h2_p6, h2_p7)
self._DOWN_ptop = plane.plane(h2_p4, h2_p1, h2_p2)
self._DOWN_pback = plane.plane(h2_p6, h2_p2, h2_p4)
self._DOWN_pfront = plane.plane(h2_p7, h2_p5, h2_p1)
def RunSim(self):
print()
print('Simulation.RunSim: simulation begins')
print('-----------------')
# Define root output stream
runNumber = 26.0 # set run number
# Define ntupleMaker called with run number; output file name; production straight data
nt = ntM.ntupleMake(runNumber, self._nuStrt, self._rootfilename)
if (nt.Version != 2.6):
raiseException("Incorrect version of ntupleMaker")
# Define the distance of the downstream plane where the flux is calculated
# parameters length of straight; distance from end of straight of plane.
fluxPlane = plane.plane(self._nuStrt.ProdStrghtLen(),
self._nuStrt.HallWallDist())
#KL! Hack runType = self._nuStrt.runType()
runType = 1
iCnt = 0
Scl = 1
prt = 0
# generate Events - which depends on the run type
# 1 is muon
# 2 is pionFlash
if (runType == 1):
print(" ----> A muon run <---- \n")
for iEvt in range(self._NEvt):
if (iEvt % Scl) == 0:
iCnt += 1
print(" Generating event ", iEvt)
prt = 1
if iCnt == 10:
Scl = Scl * 10
iCnt = 0
# Generate muon decay event
nuEvt = nuEvtInst.NeutrinoEventInstance(self._pbeam)
# write to event branch
nt.treeFill(nuEvt)
# Check intersection with downstream plane
hitE, hitMu = fluxPlane.findHitPositionMuEvt(nuEvt)
nt.fluxFill(hitE, hitMu)
# Fill some plots
self._plots.fill(hitMu)
if prt == 1:
prt = 0
print(nuEvt)
print(" End of this event simulation")
del (nuEvt)
# 2 pionFlash
elif (runType == 2):
print(" ----> A pion run <---- \n")
for iEvt in range(self._NEvt):
if (iEvt % Scl) == 0:
iCnt += 1
print(" Generating event ", iEvt)
prt = 1
if iCnt == 10:
Scl = Scl * 10
iCnt = 0
# Generate a pi to mu+munu - given the central momentum of the pion beam
piEvt = piEvtInst.PionEventInstance(self._pbeam)
nt.pionTreeFill(piEvt)
# Look at the intersection with the detector plane
hitMu = fluxPlane.findHitPositionPiEvt(piEvt)
nt.flashFluxFill(hitMu)
# Fill some plots
self._plots.fill(hitMu)
else:
print("Unrecognised run type ", runType, " check ", self._nufile,
"\n")
sys.exit("Unrecognised run type ")
nt.closeFile()
self._plots.histdo()
def step_impl(context):
context.p = plane()
mat = init_material(MAT)
g = G(outfile='path.nc',
aerotech_include=False,
header=None,
footer=None,
print_lines=False)
nomad_header(g, mat, H_STOCK + CNC_TRAVEL_Z)
g.absolute()
g.move(z=0)
if (H_STOCK < H_WOOD):
raise RuntimeError("Stock can be the same as the wood, but not lower.")
if H_STOCK > H_WOOD:
plane(g, mat, top, bounds.outer.x0, bounds.outer.y0, bounds.outer.x1,
bounds.outer.y1)
g.move(z=top)
# cut the curve
hill(g, mat, D_OUTER, bounds.center.dx, bounds.center.dy)
#center bolt
HEAD = 7.0
HEAD_H = 4.0 # was 4.5 - go a little proud
BOLT = 4.3
travel(g, mat, x=bounds.cx)
hole(g, mat, bottom, d=BOLT)
hole(g, mat, -HEAD_H, d=HEAD)
import sys import math from utility import * from material import init_material from rectangleTool import rectangleTool from mecode import G from hole import hole from plane import plane mat0 = init_material(sys.argv[1]) mat1 = init_material(sys.argv[2]) g = G(outfile='path.nc', aerotech_include=False, header=None, footer=None) nomad_header(g, mat0, CNC_TRAVEL_Z) g.absolute() g.move(z=0) plane(g, mat0, -2, 0, 0, 10, 10) tool_change(g, mat1, 1) g.move(x=2, y=2) g.move(z=-2) plane(g, mat1, -2, 0, 0, 6, 6)
def plotplane(self, iplane, res=0, interpolate=False):
t0 = self.trans_point_to_space(iplane.p)
tu = self.trans_point_to_space(iplane.u)
tv = self.trans_point_to_space(iplane.v)
tn = self.trans_point_to_space(iplane.n)
nu = ul.normalize(tu)
nv = ul.normalize(tv)
tplane = plane.plane(p=t0, n=tn)
nplane = plane.plane(p=t0, u=nu, v=nv)
print("plane equation:", "pos", t0, "u vec", tu, "v vec", tv, "normal",
tn)
# now have the transformed equation of the plane
# can think of cube as planes with boundaries
# step 0: normalize direction vectors
if res == 0:
res = self.f_size[np.argmax(tu)]
# step 1: take each cube plane and find intersections between planes
# face 1: xy plane, z = 0
c1n = np.array([0, 0, 1])
c1p = np.array([0, 0, 0])
c2n = np.array([0, 0, 1])
c2p = np.array([0, 0, self.f_size[2]])
c3n = np.array([0, 1, 0])
c3p = np.array([0, 0, 0])
c4n = np.array([0, 1, 0])
c4p = np.array([0, self.f_size[1], 0])
c5n = np.array([1, 0, 0])
c5p = np.array([0, 0, 0])
c6n = np.array([1, 0, 0])
c6p = np.array([self.f_size[0], 0, 0])
face1 = plane.plane(p=c1p, n=c1n)
face2 = plane.plane(p=c2p, n=c2n)
face3 = plane.plane(p=c3p, n=c3n)
face4 = plane.plane(p=c4p, n=c4n)
face5 = plane.plane(p=c5p, n=c5n)
face6 = plane.plane(p=c6p, n=c6n)
l1 = ul.plane_intersection(face1, tplane)
l2 = ul.plane_intersection(face2, tplane)
l3 = ul.plane_intersection(face3, tplane)
l4 = ul.plane_intersection(face4, tplane)
l5 = ul.plane_intersection(face5, tplane)
l6 = ul.plane_intersection(face6, tplane)
# step 2: are these intersections in the boundaries?
(l1valid, l1pts) = self.has_line(l1)
#print("line 1: ", l1pos, l1dir, "validity:", l1valid, l1pts)
(l2valid, l2pts) = self.has_line(l2)
#print("line 2: ", l2pos, l2dir, "validity:", l2valid, l2pts)
(l3valid, l3pts) = self.has_line(l3)
#print("line 3: ", l3pos, l3dir, "validity:", l3valid, l3pts)
(l4valid, l4pts) = self.has_line(l4)
#print("line 4: ", l4pos, l4dir, "validity:", l4valid, l4pts)
(l5valid, l5pts) = self.has_line(l5)
#print("line 5: ", l5pos, l5dir, "validity:", l5valid, l5pts)
(l6valid, l6pts) = self.has_line(l6)
#print("line 6: ", l6pos, l6dir, "validity:", l6valid, l6pts)
# step 3: get a square in the basis of the plane that encompasses the intersection completely
intersection_list = l1pts + l2pts + l3pts + l4pts + l5pts + l6pts
if not intersection_list:
sys.exit("no intersection possible")
is_np = np.array(intersection_list)
#print("intersection list = ", is_np)
is_u = np.zeros((len(intersection_list)), dtype=float)
is_v = np.zeros((len(intersection_list)), dtype=float)
for i, val in enumerate(is_np):
(is_u[i], is_v[i]) = ul.get_jk(nplane, val)
# step 4: find the range of constants in the equation of the plane (v form)
##print("is_u", is_u, "is_v", is_v)
umin = np.amin(is_u)
umax = np.amax(is_u)
vmin = np.amin(is_v)
vmax = np.amax(is_v)
# step 5: loop through points and perform interpolation if necessary
urange = umax - umin
vrange = vmax - vmin
if vrange >= urange:
vinc = vrange / res
uinc = vinc
else:
uinc = urange / res
vinc = uinc
vni = int(math.ceil(vrange / vinc))
uni = int(math.ceil(urange / uinc))
data = np.zeros((uni, vni), dtype=float)
for iu in np.arange(uni):
for iv in np.arange(vni):
dpos = np.array([0.1, 0.1, 0.1])
ipos = t0 + (nu * (umin + (iu * uinc))) + (nv * (vmin +
(iv * vinc)))
if not interpolate:
ipos = np.rint(ipos)
if self.has_point(ipos + dpos):
#print(ipos)
data[iu, iv] = self.field[int(ipos[0]),
int(ipos[1]),
int(ipos[2])]
else:
data[iu, iv] = np.nan
else:
dpos = dpos * 11
if self.has_point(ipos + dpos):
data[iu, iv] = self.interpolate(ipos)
else:
data[iu, iv] = np.nan
plt.matshow(data, cmap='hot')
plt.colorbar()
#plt.show()
return data
import plane as pl
import RandomMachine
print("game start")
a = pl.plane()
p2 = RandomMachine.test()
a.startrecord('D:\data' + '/')
gamestate = 0
turning = "p1"
while gamestate == 0:
a.print(data=a.p1919)
if turning == "p1":
a.checkemptydig(a.p1919, 1)
gamestate = a.Humaninput(1)
turning = 'p2'
elif turning == "p2":
p2.InputData__Available(a.checkemptydig(a.p1919, -1))
gamestate = a.MachineInput(p2.resulty, p2.resultx, -1)
turning = 'p1'
if gamestate == 1:
print("p1 win________")
if gamestate == -1:
print("p2 win________")
if gamestate == -2:
print("ERROR")
if gamestate == 2:
print("Draw")
a.closerecord()
def step_impl(context):
context.shape = plane()
context.shape.material.reflective = 0.5
context.shape.transform = translation(0, -1, 0)
