class HexBlock:
Xs = Vector([-1.0, -0.5, 0.5, 1, 0.5, -0.5])
Ys = Vector([.0, halfSq3, halfSq3, .0, -halfSq3, -halfSq3])
Vec = [Vector(v) for v in [(0, 1), (halfSq3, 0.5), (halfSq3, -0.5)]]
def __init__(self, win, edgeLen, center):
self.win = win
self.X, self.Y = center
self.xs = HexBlock.Xs * edgeLen
self.ys = HexBlock.Ys * edgeLen
self.edgeLen = edgeLen
self.player = None
points = []
for i in range(6):
points.append(Point(self.xs[i] + self.X, self.ys[i] + self.Y))
self.region = Polygon(points)
self.region.setWidth(2)
self.region.draw(self.win)
self.piece = Circle(Point(self.X, self.Y), self.edgeLen / 2)
def undraw(self):
self.region.undraw()
self.piece.undraw()
def clickIn(self, x, y):
dv = Vector([x - self.X, y - self.Y])
limit = halfSq3 * self.edgeLen
for v in HexBlock.Vec:
if abs(v * dv) > limit:
return False
return True
def placePiece(self, player):
if self.player == None:
self.piece.setFill(player.getColor())
self.piece.draw(self.win)
self.player = player.getNum()
return True
else:
return False
def removePiece(self):
if self.player != None:
self.player = None
self.piece.undraw()
return True
else:
return False
def getCenter(self):
return self.X, self.Y
def getPlayer(self):
return self.player
def newAABB(self, obj, owner):
obj.tl = Vector(99999, -9999, -999999)
obj.br = Vector(-99999, 9999, 999999)
for mesh in owner.getComponentsByType(MeshComponent):
for triangle in mesh.triangles:
for vertex in triangle:
obj.tl.x = min(vertex[0], obj.tl.x)
obj.tl.y = max(vertex[1], obj.tl.y)
obj.tl.z = max(vertex[2], obj.tl.z)
obj.br.x = max(vertex[0], obj.br.x)
obj.br.y = min(vertex[1], obj.br.y)
obj.br.z = min(vertex[2], obj.br.z)
def clickIn(self, x, y):
dv = Vector([x - self.X, y - self.Y])
limit = halfSq3 * self.edgeLen
for v in HexBlock.Vec:
if abs(v * dv) > limit:
return False
return True
def deserialize(ser):
num_labels = len(ser['nodes'])
num_weights = len(ser['nodes'][0]['weights'])
layer = PerceptronLayer(num_labels, num_weights, activation.from_name(ser['activation']))
for node_ser, node in zip(ser['nodes'], layer.nodes):
node.weights = Vector(node_ser['weights'])
node.bias = node_ser['bias']
return layer
def __init__(self,
position=Vector(0, 0, 0),
velocity=Vector(0, 0, 0),
acceleration=Vector(0, 0, 0),
a_position=Vector(0, 0, 0),
a_velocity=Vector(0, 0, 0),
a_acceleration=Vector(0, 0, 0),
bounded=True):
# , anchor=Vector(0,0,0)):
super().__init__()
# Linear
self.oldS = Vector(0, 0, 0)
self.S = position
self.V = velocity
self.A = acceleration
# Rotational
# Ie, rotation around x axis, y axis, z axis (euler angles)
# Very simple, temporary code.
# Note that this is in degrees
self.THETA = a_position
# theta, phi,
self.OMEGA = a_velocity
self.ALPHA = a_acceleration
self.bounded = bounded
def handle_aiming_action(self, key):
self.hero.set_state("moving")
if (key in self.movement_keys.keys()):
vector = Vector(self.movement_keys[key][0],
self.movement_keys[key][1])
zap = Zap(self.hero.x, self.hero.y)
self.add_zap_at_vector(zap, vector)
else:
return True
def eovsa_array():
''' Define EOVSA antenna array, which consists of tabulated E,N,U
locations of 15 antennas plus "array center", latitude,
longitude and elevation of array center. Returns AIPY
AntennaArray object.
'''
global lat
mperns = 0.299792458 # Meters per nanosecond
# Define antenna ENU locations. Ant 16 is the test input (0,0,0).
# Divide by mperns to convert m to ns.
ante = numpy.array([
187.86, 196.15, 175.11, 197.96, 194.11, 147.42, 266.83, 98.95, 20.35,
167.43, -442.00, 640.22, -329.06, -631.00, -213.00, 0.0
]) / mperns
antn = numpy.array([
71.74, 75.14, 77.39, 50.25, 108.86, 35.91, 67.10, 169.34, -218.49,
280.78, -138.59, -355.82, 861.82, -184.00, -187.00, 0.0
]) / mperns
antu = numpy.zeros(16)
lng = -118.286953 * numpy.pi / 180 # OVSA Longitude (radians)
elev = 1207.0 # OVSA Elevation (meters)
clat = cos(lat)
slat = sin(lat)
# Latitude rotation matrix to convert ENU to XYZ
latrot = mat([[0, -slat, clat], [1, 0, 0], [0, clat, slat]])
f = numpy.array([1.0])
beam = aipy.phs.Beam(f)
ants = []
for i in range(16):
enu = Vector([ante[i], antn[i], antu[i]])
x, y, z = enu.rotate(latrot).get()
# Apply (add) any baseline corrections
xp, yp, zp = bl_cor(x, y, z, i)
ants.append(aipy.phs.Antenna(xp, yp, zp, beam))
aa = aipy.phs.AntennaArray(ants=ants, location=(lat, lng, elev))
aa.horizon = '10:30:00'
aa.compute_pressure()
# Create some standard sources for the source catalog
srcs = []
srcs.append(aipy.amp.RadioSpecial('Sun'))
srcs.append(aipy.amp.RadioSpecial('Moon'))
cat = aipy.amp.SrcCatalog(srcs)
cat.compute(aa)
# Attach catalog to aa object
aa.cat = cat
return aa
def features(self):
"""
Returns a dict from features names to values:
- One features for each pixel (e.g. (4,3) -> 1)
- components=1
- components=2
- components=3
- Other features...
"""
if not self._features:
width = len(self.pixels[0])
height = len(self.pixels)
self._features = Vector(self.pixels[i / width][i % width] / 256.0
for i in xrange(width * height))
return self._features
def addSVAComponent(self,
position=Vector(0, 0, 0),
velocity=Vector(0, 0, 0),
acceleration=Vector(0, 0, 0),
a_position=Vector(0, 0, 0),
a_velocity=Vector(0, 0, 0),
a_acceleration=Vector(0, 0, 0),
bounded=True):
self.addComponent(
SVAComponent(position, velocity, acceleration, a_position,
a_velocity, a_acceleration, bounded))
def locate(self, p):
x, y = p.getX(), p.getY()
if self.size == 1:
if self.grid[0][0].clickIn(x, y):
return (0, 0)
else:
return ()
elif self.size == 2:
cord1 = 0
cord2 = 0
else:
dv = Vector([x - self.Xo, y - self.Yo])
prod1 = dv * HexBoard.Vec[1]
prod2 = dv * HexBoard.Vec[0]
if halfSq3 * dv[1] + 0.5 * dv[0] > 0:
param1 = -1 #rotate 30 degree counter-clockwise
else:
param1 = 1
if halfSq3 * dv[1] - 0.5 * dv[0] < 0:
param2 = -1 #rotate 30 degree clockwise
else:
param2 = 1
cord1 = int((prod1 + param1 * math.sqrt(
(dv * dv - prod1 * prod1) / 3)) / (sq3 * self.gridLen))
cord2 = int((prod2 + param2 * math.sqrt(
(dv * dv - prod2 * prod2) / 3)) / (sq3 * self.gridLen))
if not (0 <= cord1 < self.size and 0 <= cord2 < self.size):
return ()
if self.grid[cord1][cord2].clickIn(x, y):
return (cord1, cord2)
elif cord1 + 1 < self.size and self.grid[cord1 + 1][cord2].clickIn(
x, y):
return (cord1 + 1, cord2)
elif cord2 + 1 < self.size and self.grid[cord1][cord2 + 1].clickIn(
x, y):
return (cord1, cord2 + 1)
elif cord1 + 1 < self.size and cord2 + 1 < self.size and self.grid[
cord1 + 1][cord2 + 1].clickIn(x, y):
return (cord1 + 1, cord2 + 1)
else:
return ()
def update(self, _):
# First, update for changes in SVA
for e, c in self.eman.pairsForType(CollisionComponent):
if c.AABB:
self.newAABB(c, e)
for e0, c0 in self.eman.pairsForType(CollisionComponent):
if c0.active:
for e1, c1 in self.eman.pairsForType(CollisionComponent):
if e0 is not e1 and c1.active and c1.type_ in c0.typeCollide:
if c0.AABB and c1.AABB:
bCollides = self.collidesWithAABB(c0, c1)
#bCollides = self.collidesWithTriangles(c0, c1)
else:
# Triangle intersections, baby!
bCollides = self.collidesWithTriangles(c0, c1)
if bCollides:
s = e0.getSingleComponentByType(SVAComponent)
s.A = Vector(x=0, y=1, z=0, w=1)
print(e0, " collides with ", e1)
print(int(round(time.time() * 1000)))
class HexBoard:
Vec = [Vector(v) for v in [(halfSq3, 0.5), (halfSq3, -0.5)]]
adVec = [
Vector(v) for v in [(1, 0), (0, 1), (-1, 0), (0, -1), (-1, 1), (1, -1)]
]
def __init__(self, win, size, gridLen, origin):
self.active = True
self.mark1, self.mark2 = [0] * size, [0] * size
self.win = win
self.size = size
self.gridLen = gridLen
self.grid = []
self.moveStack = Stack(size * size)
for i in range(size):
self.grid.append([])
self.Xo, self.Yo = origin.getX(), origin.getY()
pio = self.Xo, self.Yo
for i in range(size):
newCenter = pio
for j in range(size):
newGrid = HexBlock(win, gridLen, newCenter)
self.grid[i].append(newGrid)
newCenter = (newCenter[0] + 1.5 * gridLen,
newCenter[1] + halfSq3 * gridLen)
pio = (pio[0] + 1.5 * gridLen, pio[1] - halfSq3 * gridLen)
self.drawOuterLines()
def undraw(self):
if not self.active:
return
map(lambda item: item.undraw, self.lines)
map(lambda row: map(lambda item: item.undraw(), row), self.grid)
self.active = False
def drawOuterLines(self):
self.lines = []
p1 = Point(self.Xo - self.gridLen * 2, self.Yo)
p2 = Point(self.Xo + 1.5 * (self.size - 1) * self.gridLen,
self.Yo + halfSq3 * (self.size + 1.0 / 3) * self.gridLen)
p3 = Point(self.Xo + (3 * self.size - 1) * self.gridLen, self.Yo)
p4 = Point(self.Xo + 1.5 * (self.size - 1) * self.gridLen,
self.Yo - halfSq3 * (self.size + 1.0 / 3) * self.gridLen)
ps = [p1, p2, p3, p4]
for i in range(4):
self.lines.append(Line(ps[i], ps[(i + 1) % 4]))
if i % 2:
self.lines[i].setOutline("red")
else:
self.lines[i].setOutline("blue")
self.lines[i].setWidth(2)
self.lines[i].draw(self.win)
def locate(self, p):
x, y = p.getX(), p.getY()
if self.size == 1:
if self.grid[0][0].clickIn(x, y):
return (0, 0)
else:
return ()
elif self.size == 2:
cord1 = 0
cord2 = 0
else:
dv = Vector([x - self.Xo, y - self.Yo])
prod1 = dv * HexBoard.Vec[1]
prod2 = dv * HexBoard.Vec[0]
if halfSq3 * dv[1] + 0.5 * dv[0] > 0:
param1 = -1 #rotate 30 degree counter-clockwise
else:
param1 = 1
if halfSq3 * dv[1] - 0.5 * dv[0] < 0:
param2 = -1 #rotate 30 degree clockwise
else:
param2 = 1
cord1 = int((prod1 + param1 * math.sqrt(
(dv * dv - prod1 * prod1) / 3)) / (sq3 * self.gridLen))
cord2 = int((prod2 + param2 * math.sqrt(
(dv * dv - prod2 * prod2) / 3)) / (sq3 * self.gridLen))
if not (0 <= cord1 < self.size and 0 <= cord2 < self.size):
return ()
if self.grid[cord1][cord2].clickIn(x, y):
return (cord1, cord2)
elif cord1 + 1 < self.size and self.grid[cord1 + 1][cord2].clickIn(
x, y):
return (cord1 + 1, cord2)
elif cord2 + 1 < self.size and self.grid[cord1][cord2 + 1].clickIn(
x, y):
return (cord1, cord2 + 1)
elif cord1 + 1 < self.size and cord2 + 1 < self.size and self.grid[
cord1 + 1][cord2 + 1].clickIn(x, y):
return (cord1 + 1, cord2 + 1)
else:
return ()
def placePiece(self, cord, player):
success = self.grid[cord[0]][cord[1]].placePiece(player)
if not success: return False
n = player.getNum()
if n == 1: self.mark1[cord[0]] += 1
elif n == 2: self.mark2[cord[1]] += 1
self.moveStack.push(HexMove(player, cord))
return success
def removePiece(self):
cord = self.moveStack.pop()
if cord != None:
cord = cord.getPos()
else:
return False
n = self.grid[cord[0]][cord[1]].getPlayer()
success = self.grid[cord[0]][cord[1]].removePiece()
if not success: return False
if n == 1: self.mark1[cord[0]] -= 1
elif n == 2: self.mark2[cord[1]] = -1
return success
def redo(self):
item = self.moveStack.redo()
if item != None:
player = item.getPlayer()
cord = item.getPos()
success = self.grid[cord[0]][cord[1]].placePiece(player)
if not success: return False
n = player.getNum()
if n == 1: self.mark1[cord[0]] += 1
elif n == 2: self.mark2[cord[1]] += 1
return False
def winner(self):
if 0 in self.mark1 and 0 in self.mark2: return None
if self.scan(1):
return 1
elif self.scan(2):
return 2
else:
return None
def inRange(self, pos):
return 0 <= pos[0] < self.size and 0 <= pos[1] < self.size
def getAdjacent(self, iset):
adjacent = set()
for item in iset:
for v in HexBoard.adVec:
candidate = tuple(map(sum, zip(item, v)))
if self.inRange(candidate): adjacent.add(candidate)
return adjacent
def scan(self, player):
adjacent = set()
for j in range(self.size):
iset = set()
for i in range(self.size):
if player == 1:
p = self.grid[j][i].getPlayer()
additem = (j, i)
elif player == 2:
p = self.grid[i][j].getPlayer()
additem = (i, j)
if player == p:
iset.add(additem)
if iset.isdisjoint(adjacent) and j > 0:
return False
adjacent = self.getAdjacent(iset)
return True
def getGrid(self):
return self.grid
def getStack(self):
return self.moveStack
class Direction(object):
UP = Vector(0, -1)
DOWN = Vector(0, 1)
LEFT = Vector(-1, 0)
RIGHT = Vector(1, 0)
elif option == 1:
if vectores.count() == 0:
if not os.path.exists('data/vectores.txt'):
print 'Copie y pegue sus 2000 vectores en la carpeta data, yo le espero'
time.sleep(3.5)
print 'yamete kudasai onii-chan'
else:
arch = open('data/vectores.txt', 'r')
data = arch.readlines()
arch.close()
#begin creation and insertion
for vec_txt in data:
vectores.insert_one(Vector(vec_txt).__dict__)
del arch, data #release
print 'data stored in mongodb!'
else:
print 'mongodb already contains data'
elif option == 2:
vec_cursor = vectores.find()
try:
for i in range(5):
pprint(vec_cursor.next())
except StopIteration:
def __init__(self, layer, num_weights):
self.layer = layer
self.weights = Vector(random.gauss(0, 0.01) for _ in xrange(num_weights))
self.bias = random.gauss(0, 0.01)
def feed_forward(self, example):
return Vector(node.feed_forward(example) for node in self.nodes)
def _compute_one_parameter(self, param_value, index):
source_position = np.array([
get_scarray_value(self.args.source_position_x, index),
get_scarray_value(self.args.source_position_y, index),
get_scarray_value(self.args.source_position_z, index)
])
axis = Vector(x_angle=get_scarray_value(self.args.axis_angle_x, index),
y_angle=get_scarray_value(self.args.axis_angle_y, index),
z_angle=get_scarray_value(self.args.axis_angle_z, index),
position=[
get_scarray_value(self.args.center_position_x,
index), 0,
get_scarray_value(self.args.center_position_z, index)
])
detector = Vector(x_angle=get_scarray_value(self.args.detector_angle_x,
index),
y_angle=get_scarray_value(self.args.detector_angle_y,
index),
z_angle=get_scarray_value(self.args.detector_angle_z,
index),
position=[
get_scarray_value(self.args.detector_position_x,
index),
get_scarray_value(self.args.detector_position_y,
index),
get_scarray_value(self.args.detector_position_z,
index)
])
volume_angle = Vector(
x_angle=get_scarray_value(self.args.volume_angle_x, index),
y_angle=get_scarray_value(self.args.volume_angle_y, index),
z_angle=get_scarray_value(self.args.volume_angle_z, index))
z = self.args.z
if self.args.z_parameter == 'z':
z = param_value
elif self.args.z_parameter == 'axis-angle-x':
axis.x_angle = param_value
elif self.args.z_parameter == 'axis-angle-y':
axis.y_angle = param_value
elif self.args.z_parameter == 'axis-angle-z':
axis.z_angle = param_value
elif self.args.z_parameter == 'volume-angle-x':
volume_angle.x_angle = param_value
elif self.args.z_parameter == 'volume-angle-y':
volume_angle.y_angle = param_value
elif self.args.z_parameter == 'volume-angle-z':
volume_angle.z_angle = param_value
elif self.args.z_parameter == 'detector-angle-x':
detector.x_angle = param_value
elif self.args.z_parameter == 'detector-angle-y':
detector.y_angle = param_value
elif self.args.z_parameter == 'detector-angle-z':
detector.z_angle = param_value
elif self.args.z_parameter == 'detector-position-x':
detector.position[0] = param_value
elif self.args.z_parameter == 'detector-position-y':
detector.position[1] = param_value
elif self.args.z_parameter == 'detector-position-z':
detector.position[2] = param_value
elif self.args.z_parameter == 'source-position-x':
source_position[0] = param_value
elif self.args.z_parameter == 'source-position-y':
source_position[1] = param_value
elif self.args.z_parameter == 'source-position-z':
source_position[2] = param_value
elif self.args.z_parameter == 'center-position-x':
axis.position[0] = param_value
elif self.args.z_parameter == 'center-position-z':
axis.position[2] = param_value
else:
raise RuntimeError("Unknown z parameter '{}'".format(
self.args.z_parameter))
points = get_extrema(self.args.x_region, self.args.y_region, z)
if self.args.z_parameter != 'z':
points_upper = get_extrema(self.args.x_region, self.args.y_region,
z + 1)
points = np.hstack((points, points_upper))
tomo_angle = float(index) / self.args.number * self.args.overall_angle
xe, ye = compute_detector_pixels(points, source_position, axis,
volume_angle, detector, tomo_angle)
return compute_detector_region(xe,
ye, (self.args.height, self.args.width),
overhead=self.args.projection_margin)
