def nextTriangle(A,B,C):
[B,C,A] = Vector.sort([A,B,C])
D = B + C - A
E = 3* (B+C)/ 2- 2*A
F = (3* (B+C)- 2*A)/4
G = (2* A+ B+ C)/4
if F.cost() < G.cost():
X = Vector(F)
else:
X = Vector(G)
#case 1: vertex A moves to D or E
if D.cost() < A.cost() and E.cost() < A.cost():
A.equals(E)
elif D.cost() < A.cost():
A.equals(D)
#case 2: vertex A moves to F or G
elif X.cost() < A.cost():
A.equals(X)
#case 3: vertex A moves to H and vertex C moves to I
else:
H = (A + B)/2
I = (B + C)/2
A.equals(H)
C.equals(I)
return A,B,C
def Specular(aNormal,aTrianglePoint):
eyeVector = [cameraX - aTrianglePoint[X],
cameraY - aTrianglePoint[Y],
cameraZ - aTrianglePoint[Z],
1.0 - aTrianglePoint[3]]
eyeVector = Vector.normalize(eyeVector)
lightVec = [lightPoint[X] - aTrianglePoint[X],
lightPoint[Y] - aTrianglePoint[Y],
lightPoint[Z] - aTrianglePoint[Z],
lightPoint[W] - aTrianglePoint[W]]
lightVec = Vector.normalize(lightVec)
#caculate the half vector
H = [lightVec[X] + eyeVector[X],
lightVec[Y] + eyeVector[Y],
lightVec[Z] + eyeVector[Z],
lightVec[W] + eyeVector[W]]
#now normalize and dot the half with the normal vec,
#use the shininess constant defined in IncludesAndConstants.py
H = Vector.normalize(H)
d = Vector.dotProduct(aNormal,H)
return math.pow(max(d,0),shininess)
def resetControl(self):
self.switch = 0
self.error = Vector(0,0)
self.errorPrev = Vector(0,0)
self.derror = Vector(0,0)
self.errorSum = Vector(0,0)
self.program = None
def oscillateCurve( curve, start=0.0, end=1.0, freq=1.0, ease=0.5, strength=1.0 ):
""" Oscillates a given curve by moving each vertex in an alternating
direction based on the normal. This process takes place over the
range defined by "start" and "end" as percentages of arc length.
Oscillation eases to full strength as determined by the "ease" and
"strength" arguments. """
if(ease > (end-start)*0.5):
ease = (end-start)*0.5
if(start < end):
CVs = mc.getAttr( curve+".cv[*]" )
newCVs = findCVsInRange(curve, start, end)
for (I,U,L) in newCVs:
interp = (L-start)/(end-start)
osc = sin(freq*interp)
scale = pulse(start+ease, end, ease, L) # ease must be between 0 and 0.5
## Don't use Maya's normalized normal -- it flip flops with curvature so it's not good for oscillating offset
# normal = Vector(mc.pointOnCurve(curve, parameter=cv[1], normalizedNormal=True))
# if(normal.mag() == 0.0):
# print "Getting normal from up x tangent"
normal = Vector(0,1,0)**Vector(mc.pointOnCurve(curve, parameter=U, tangent=True))
normal = normal.norm()
pos = Vector(CVs[I])
pos = pos+normal*scale*strength*osc
CVs[I] = pos.asTuple()
for i,cv in enumerate(CVs):
mc.setAttr(curve+".cv[%d]"%i, cv[0], cv[1], cv[2])
return curve
class Obstacle:
def __init__(self,x,y,vx,vy):
self.pos = Vector(x,y)
self.vel = Vector(vx,vy)
self.acc = Vector(0,1)
self.c = color(random(60),random(80),random(255))
self.radius = 10
self.elasticity = 0.9
self.dead = False
self.life = 0
self.inc = 1
def isDead(self):
return self.dead
def getX(self):
return self.pos.getX()
def getY(self):
return self.pos.getY()
def getR(self):
return self.radius
def render(self):
fill(self.c)
wall = loadImage("Wall.png")
image(wall, self.pos.getX(),self.pos.getY())
def update(self):
#Lifetime
self.life += self.inc
if self.life > 1000:
self.dead = True
def reinit(self): self.pos = Vector(Conf.TURTLE.INIT_POS) self.heading = Vector(Conf.TURTLE.INIT_HEADING) self.color = Vector(colorsys.rgb_to_hls(Conf.TURTLE.INIT_COLOR[0], Conf.TURTLE.INIT_COLOR[1], Conf.TURTLE.INIT_COLOR[2])) self.vertexBuffer = [] self.vertexBufferChanged = False self.vertexBufferLength = 0 self.vertexPositions = vbo.VBO(np.array(self.vertexBuffer, dtype=np.float32)) self.vertexPositions.bind()
def __init__(self,x,y,vx,vy):
self.pos = Vector(x,y)
self.vel = Vector(vx,vy)
self.acc = Vector(0,1)
self.c = color(random(60),random(80),random(255))
self.radius = 10
self.elasticity = 0.8
self.dead = False
self.life = 0
self.inc = 1
def execute(*args):
"""Test all derived functions for proper operation
"""
import Vector
reload(Vector)
Vector.test()
import Add
reload(Add)
Add.test()
import Multiply
reload(Multiply)
Multiply.test()
import Divide
reload(Divide)
Divide.test()
import Difference
reload(Difference)
Difference.test()
import Poly
reload(Poly)
Poly.test()
import Average
reload(Average)
Average.test()
import LinTrans
reload(LinTrans)
LinTrans.test()
import Test
reload(Test)
Test.test()
import Rotate
reload(Rotate)
Rotate.test()
import Magnitude
reload(Magnitude)
Magnitude.test()
import Cape
reload(Cape)
Cape.test()
print "-"*60
print "Function Test Complete"
def __init__(self, dt):
self.dt = dt
self.rotorspeed = Vector(0.0, 0.0)
self.pos = Vector(0,0)
self.speed = Vector(0.0,0.0)
self.acc = Vector(0.0, 0.0)
self.posPrev = Vector(0.0, 0.0)
self.speedPrev = Vector(0.0, 0.0)
self.control = None
def getMinMaxItems(self): self.itemMAX = Vector(self.iteminfo[0][0]) self.itemMIN = Vector(self.iteminfo[0][0]) self.itemMEAN = Vector(self.iteminfo[0][0]) for idx in range(1, len(self.iteminfo)): self.itemMAX.upper( self.iteminfo[idx][0] ) self.itemMIN.lower( self.iteminfo[idx][0] ) self.itemMEAN += self.iteminfo[idx][0] #print self.iteminfo[idx][0].str() #print self.itemMAX.str() #print self.itemMIN.str() self.itemMEAN /= len(self.iteminfo)
def Diffuse(aNormal,aTrianglePoint):
lightVec = [ lightPoint[X] - aTrianglePoint[X],
lightPoint[Y] - aTrianglePoint[Y],
lightPoint[Z] - aTrianglePoint[Z],
lightPoint[W] - aTrianglePoint[W]]
lightVec = Vector.normalize(lightVec)
#print(lightVec[X],lightVec[Y],lightVec[Z])
#print(Vector.length(lightVec))
aNormal = Vector.normalize(aNormal)
return max(Vector.dotProduct(lightVec,aNormal),0)
def createDendrites(self):
angle = 360.0/self.branches
startDist = 0.95 * self.somaSize
endDist = startDist + self.stepDist
halfThickness = self.dendriteThickness/2.0
a = 0.0
while a<360.0:
# Define the points that the dendrite would follow if it were a line (i.e. no thickness)
initialResources = self.maxRadius
p1, p2 = Vector(), Vector()
p1.x = m.cos(m.radians(a)) * startDist + self.center.x
p1.y = m.sin(m.radians(a)) * startDist + self.center.y
p2.x = m.cos(m.radians(a)) * endDist + self.center.x
p2.y = m.sin(m.radians(a)) * endDist + self.center.y
remainingResources = initialResources - p1.distance(p2)
# Find the first and last vertex of the quad (moving perpendicular from p1 to create thickness)
t = p1 - self.center
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
v1 = leftPerp * halfThickness + p1
v4 = rightPerp * halfThickness + p1
# Find the second and third vertex of the quad (moving perpendicular from p2 to create thickness)
t = p2 - p1
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
v2 = leftPerp * halfThickness + p2
v3 = rightPerp * halfThickness + p2
# Find the vertex index of the newly added vertices
startVertexNumber = len(self.verts)
v1Number = startVertexNumber
v2Number = startVertexNumber + 1
v3Number = startVertexNumber + 2
v4Number = startVertexNumber + 3
# Add the vertices
self.verts = self.verts + [v1.toList(), v2.toList(), v3.toList(), v4.toList()]
# Add a properly ordered face
face = self.createOrderedQuad(v1, v2, v3, v4, v1Number, v2Number, v3Number, v4Number)
self.faces.append(face)
# Store some information about the current dendrite branch
self.dendrites.append([[a,initialResources,p1,[v1,v1Number],[v4,v4Number]],
[a,remainingResources,p2,[v2,v2Number],[v3,v3Number]]])
self.lineSegments.append([p1, (p1+p2)/2.0, p2])
self.updateRadius(v1, v2, v3, v4)
a += angle
def runRandomSearch():
startTime = clock()
vector = Vector(random()*DOMAIN_LIMIT,random()*DOMAIN_LIMIT)
minc= vector.cost()
while(clock() - startTime < MAX_RUN_TIME):
global PROBE_COUNT1
PROBE_COUNT1+=1
vector = Vector(random()*DOMAIN_LIMIT,random()*DOMAIN_LIMIT)
if(vector.cost() < minc):
minc = vector.cost()
print('2. Random Probing used', PROBE_COUNT1, 'probes.')
print('Vector =', vector, 'Cost =', round(minc,5))
print('---Search time =', round(clock() - startTime, 2), 'seconds\n')
def TestForCull(aTriangle):
camVector = [IncludesAndConstants.lookPointX - IncludesAndConstants.cameraX,
IncludesAndConstants.lookPointY - IncludesAndConstants.cameraY,
IncludesAndConstants.lookPointZ - IncludesAndConstants.cameraZ,0]
camVector = Vector.normalize(camVector)
normal = [aTriangle.normal[X],aTriangle.normal[Y],aTriangle.normal[Z],0]
normal = Vector.normalize(normal)
if Vector.dotProduct(camVector,normal) <= 0.0:
return True
else:
return False
def testAssignmentOperators() :
V = Vector([1.0, 2.0, 3.0])
print V.size()
V.show()
W = V
W.show()
for k in range(V.size()) :
print V[k]
for k in range(V.size()) :
V[k] = 0.0
V.show()
def __init__(self, drone):
self.drone = drone
self.error = Vector(0,0)
self.errorPrev = Vector(0,0)
self.derror = Vector(0,0)
self.errorSum = Vector(0,0)
self.program = ""
self.params = []
self.switch = 0
self.p = [1.920992106546498, 1.4674037935865036, 1.2306011558472907]
drone.setControl(self)
def __init__(self):
self.up = Vector([0,1,0])
self.position = Vector([0,0,-5])
self.lookat = Vector([0,0,0])
self.keysDown = {}
self.keysDownSpecial = {}
self.debug = None
def initializeGrowth(self, stepSize, heading, headingRange):
self.p2 = Vector()
self.p2.x = m.cos(m.radians(heading)) * stepSize + self.p1.x
self.p2.y = m.sin(m.radians(heading)) * stepSize + self.p1.y
thickness = (self.resources/self.maxResources) * (self.startThickness - self.endThickness) + self.endThickness
halfThickness = thickness / 2.0
t = self.p1 - self.cellCenter
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
self.v1 = leftPerp * halfThickness + self.p1
self.v4 = rightPerp * halfThickness + self.p1
t = self.p2 - self.p1
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
self.v2 = leftPerp * halfThickness + self.p2
self.v3 = rightPerp * halfThickness + self.p2
self.vertices = self.vertices + [self.v1] + [self.v2] + [self.v3] + [self.v4]
self.points = self.points + [self.p1] + [self.p2]
self.resources -= stepSize
if self.resources <= 0: self.growing = False
def storeresponse(answers):
answersstr = "', '".join(answers)
db = sql()
cur = db[0]
conn = db[1]
#conn = sql()[1]
#cur = sql()[0]
print "***************************"
query = "INSERT INTO sjsu.User_Response (SJSU_ID, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10, Q11, Q12, Q13, Q14, Q15, Q16, Q17, Q18, Q19, Q20, Major) VALUES('" + answersstr + "', NULL)"
print query
cur.execute(query)
print "***************************"
last_id = str(cur.lastrowid)
print "***************************"
print "Your User Response ID is " + last_id +"."
#cur.commit()
# Seperate function?
qanswers = map(int,answers[1:])
recommendation = Vector.distcheck(qanswers)
print ("Your recommended major is: " + recommendation[0])
cur.execute("UPDATE User_Response SET Rec_Major = '" + recommendation[1] + "' WHERE User_Response_ID = " + last_id)
def plotTriangle(self, triangle): v0 = self.project(triangle.p1) v1 = self.project(triangle.p2) v2 = self.project(triangle.p3) v0.z = 1.0/v0.z v1.z = 1.0/v1.z v2.z = 1.0/v2.z x_min = int(min(v0.x, v1.x, v2.x)) x_max = int(max(v0.x, v1.x, v2.x) + 1) y_min = int(min(v0.y, v1.y, v2.y)) y_max = int(max(v0.y, v1.y, v2.y) + 1) x_min = max(0, x_min) x_max = min(self.width, x_max) y_min = max(0, y_min) y_max = min(self.height, y_max) area = self.edgeFunction(v0, v1, v2) for x in range(x_min, x_max): for y in range(y_min, y_max): p = Vector(x,y,0) w0 = self.edgeFunction(v1, v2, p) w1 = self.edgeFunction(v2, v0, p) w2 = self.edgeFunction(v0, v1, p) if w0 >= 0 and w1 >= 0 and w2 >=0: w0 /= area w1 /= area w2 /= area z = (1.0/(v0.z * w0 + v1.z * w1 + v2.z * w2)) if (z < self.depth_buffer[y][x]): self.depth_buffer[y][x] = z v0cam = self.world_matrix.transformPoint(triangle.p1) v1cam = self.world_matrix.transformPoint(triangle.p2) v2cam = self.world_matrix.transformPoint(triangle.p3) px = (v0cam.x/-v0cam.z) * w0 + (v1cam.x/-v1cam.z) * w1 + (v2cam.x/-v2cam.z) * w2 py = (v0cam.y/-v0cam.z) * w0 + (v1cam.y/-v1cam.z) * w1 + (v2cam.y/-v2cam.z) * w2 pt = Vector(px * z, py * z, z) n = (v1cam - v0cam).cross(v2cam - v0cam).normalized() view_direction = pt.normalized() view_direction = Vector(-pt.x, -pt.y, -pt.z).normalized() cosine = max(0, n.dot(view_direction)) self.plotPoint(x,y, cosine * 255)
def growDendrite(self, i):
dendrite = self.dendrites[i]
step = self.stepDist
halfThickness = self.dendriteThickness/2.0
# Load this dendrite's information
heading = dendrite[-1][0]
resources = dendrite[-1][1]
p1 = dendrite[-1][2]
v1, v1Number = dendrite[-1][3]
v4, v4Number = dendrite[-1][4]
thickness = resources/self.maxRadius * (self.dendriteThickness - self.minDendriteThickness) + self.minDendriteThickness
halfThickness = thickness / 2.0
# Generate a random heading in order to create p2
heading += r.uniform(-self.headingRange, self.headingRange)
p2 = Vector()
p2.x = p1.x + m.cos(m.radians(heading)) * step
p2.y = p1.y + m.sin(m.radians(heading)) * step
resources = resources - p1.distance(p2)
# Calculate the new vertices of the quad (adding thickness)
t = p2 - p1
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
v2 = leftPerp * halfThickness + p2
v3 = rightPerp * halfThickness + p2
# Find the vertex index of the newly added vertices
startVertexNumber = len(self.verts)
v2Number = startVertexNumber
v3Number = startVertexNumber + 1
# Add the vertices
self.verts = self.verts + [v2.toList(), v3.toList()]
# Add a properly ordered face
face = self.createOrderedQuad(v1, v2, v3, v4, v1Number, v2Number, v3Number, v4Number)
self.faces.append(face)
# Store some information about the current dendrite branch
self.dendrites[i].append([heading, resources, p2, [v2,v2Number], [v3,v3Number]])
self.lineSegments.append([p1, (p1+p2)/2.0, p2])
self.updateRadius(v1, v2, v3, v4)
def distance_to_r(self):
'''
:return: return the cat radius
'''
self.r = Vector(450, 350).distance(self.position)
if self.r < 90:
self.position = Vector(600,350)
self.r = Vector(450, 350).distance(self.position)
return self.r
def CreateTransformedNormal(aTriangle):
vec1 = [aTriangle.p1[X] - aTriangle.p2[X],aTriangle.p1[Y] - aTriangle.p2[Y],
aTriangle.p1[Z] - aTriangle.p2[Z]]
vec2 = [aTriangle.p3[X] - aTriangle.p2[X],aTriangle.p3[Y] - aTriangle.p2[Y],
aTriangle.p3[Z] - aTriangle.p2[Z]]
aTriangle.normal = Vector.crossProduct(vec2,vec1)
return aTriangle.normal
def __init__(self, pos=None): if pos is None: self.pos = Vector(Conf.TURTLE.INIT_POS) else: self.pos = Vector(pos) self.heading = Vector(Conf.TURTLE.INIT_HEADING) self.color = Vector(colorsys.rgb_to_hls(Conf.TURTLE.INIT_COLOR[0], Conf.TURTLE.INIT_COLOR[1], Conf.TURTLE.INIT_COLOR[2])) self.stateStack = [] # allow to manage a stack of states self.stochasticFactor = 0 # used to randomize drawing # the vertex buffer is a liste of lists : [[x y z r g b time],...] self.vertexBuffer = [] self.vertexBufferLength = 0 self.vertexBufferChanged = False self.vertexPositions = None #indices = np.array([[0,1,2], [0, 3, 2]], dtype=np.int32) self.draw_type = GL_TRIANGLES self.point()
def ClosestTimeTo( self, point, plane=None ):
""" Returns the closest point in this trajectory to the given point in 3d space (or 2d if plane is defined) """
if not type(point) == Vector:
point = Vector(point)
if plane:
point = point.projectToPlane(plane.normal,planePt=plane.point)
minDist = float("inf")
ft = None
camPos = Vector( mc.xform(mc.lookThru(q=True), q=True, t=True) )
for i,t in enumerate(sorted(self.points.keys())):
p = self.points[t]
if plane:
p = p.projectToPlane(plane.normal,planePt=plane.point)
dist = (point-p).mag()
else:
ray = (p-camPos).norm() # build a ray from the camera to the path point in question
dist = ray.cross(point-p).mag()
if minDist > dist:
minDist = dist
ft = t
return ft # return the key of the closest point in the points dictionary
def testVectorOperators() : V = Vector([0.0, 1.0, 2.0]) W = Vector([3.0, 4.0, 5.0]) print V.dot(W) print V.norm() U = V.cross(W) U.show()
def step(p1,p2):#radius=1
X1 = Vector(p1,p2)
for t in frange(0, pi*2, pi/4):
X = Vector(p1 + (cos(t)), p2 + (sin(t)))
if X.cost() < X1.cost():
X1.equals(X)
return X1
def __init__(self):
self.image = 17
self.framenumber = 0
self.swinging = 4;
self.gunmode = False;
pygame.sprite.Sprite.__init__(self)
self.images = [pygame.image.load(os.path.join(os.curdir, 'spritel1.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel2.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel3.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel4.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel5.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel6.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel7.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spritel8.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter1.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter2.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter3.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter4.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter5.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter6.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter7.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'spriter8.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'jump.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'start.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'bowl.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'bowr.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'hurt.png')).convert_alpha(),
pygame.image.load(os.path.join(os.curdir, 'dead.png')).convert_alpha()
]
self.rect = self.images[self.image].get_rect()
self.rect = self.rect.move(300,600)
self.vel = 0
self.x = 300
self.y = 600
self.dir = 1 # 1: Right -1: Left
self.vector = Vector(self.x,self.y)
self.Arrows = 20
self.ArrowsMax = 20
self.ArrowsRepl = 0.0
self.ArrowsReplRate = 0.1
self.Gravity = 100
self.GravityRepl = 0.0
self.RapidFire = False
self.MultiShot = False
self.MultiShot2 = False
self.Lives = 5
self.Repel = 8
self.DecoyNum = 5
self.DecoyCounter = 0
self.DecoyX = 0
self.DecoyY = 0
def noiseCurve( curve, start=0.0, end=1.0, freq=1.0, ease=0.5, strength=1.0 ):
""" Adds noise to a given curve by moving each vertex with Perlin
noise based on the normal. This process takes place over the
range defined by "start" and "end" as percentages of arc length.
Noise eases to full strength as determined by the "ease" and
"strength" arguments. """
if(ease > (end-start)*0.5): # ease must be between 0 and 0.5
ease = (end-start)*0.5
if(start < end):
CVs = mc.getAttr( curve+".cv[*]" )
newCVs = findCVsInRange(curve, start, end)
for (I,U,L) in newCVs:
interp = (L-start)/(end-start)
noiz = noise(freq*interp)
scale = pulse(start+ease, end, ease, L)
normal = Vector(0,1,0)**Vector(mc.pointOnCurve(curve, parameter=U, tangent=True))
normal = normal.norm()
pos = Vector(CVs[I])
pos = pos+normal*scale*strength*noiz
CVs[I] = pos.asTuple()
for i,cv in enumerate(CVs):
print(curve+".cv[%d]"%cv[0], cv[0], cv[1], cv[2])
mc.setAttr(curve+".cv[%d]"%i, cv[0], cv[1], cv[2])
def regularGrowth(self, stepSize=None, heading=None, headingRange=None):
# Start growing from the last dendrite points (deep copies)
self.p1 = self.p2.copyVector()
self.v1 = self.v2.copyVector()
self.v4 = self.v3.copyVector()
# Unlink any references that exist
self.p2 = Vector()
self.v2 = Vector()
self.v3 = Vector()
# Map the resources remaining into the range of thickness values to obtain the current thickness
thickness = remap(self.resources, 0.0, self.maxResources, self.startThickness, self.endThickness)
halfThickness = thickness / 2.0
# Generate a random heading
heading += r.uniform(-self.headingRange, self.headingRange)
# Find p2 by moving in the heading direction
self.p2.x = self.p1.x + m.cos(m.radians(heading)) * stepSize
self.p2.y = self.p1.y + m.sin(m.radians(heading)) * stepSize
# Calculate the new vertices of the quad (adding thickness relative to p2)
t = self.p2 - self.p1
leftPerp = t.leftXYPerpendicular().normalize()
rightPerp = t.rightXYPerpendicular().normalize()
self.v2 = leftPerp * halfThickness + self.p2
self.v3 = rightPerp * halfThickness + self.p2
# Store the new vertices and the new point
self.vertices = self.vertices + [self.v2] + [self.v3]
self.points = self.points + [self.p2]
# Update the resources based on distance traveled
self.resources -= stepSize
if self.resources <= 0: self.growing = False
def __init__(self,solver,a=Vector.Vector(x=0,y=0,z=-9.81),c=0):
self.solver = solver
self.a = a
self.c = c
def testArea(self):
c = Vector.Vector([0, 0])
r = 1
o = Circle.Circle(c, r)
self.assertEqual(o.area(), math.pi)
def position(self):
return Vector(x, y)
class Vehicle:
def __init__(self, x, y, world):
self.pos = Vector(x, y)
self.vel = Vector(1, 0)
self.acc = Vector(0, 0)
self.maxSpeed = 6
self.maxForce = .5
self.size = 10 # radius
self.world = world
def borders(self):
if self.pos.x < -self.size:
self.pos.x = self.world.width + self.size
elif self.pos.x > self.world.width + self.size:
self.pos.x = -self.size
if self.pos.y < -self.size:
self.pos.y = self.world.height + self.size
elif self.pos.y > self.world.height + self.size:
self.pos.y = -self.size
def run(self):
self.borders()
self.update()
def update(self):
self.vel.add(self.acc)
self.vel.limitMag(self.maxSpeed)
self.pos.sub(self.vel)
self.acc.set(0, 0)
def applyForce(self, force):
# can add mass a = f / m
self.acc.add(force)
def seek(self, target):
desired = Vector.subTwo(self.pos, target)
desired.setMag(self.maxSpeed)
steer = Vector.subTwo(desired, self.vel)
steer.limitMag(self.maxForce)
return steer
def arrive(self, target):
desired = Vector.subTwo(self.pos, target)
speed = self.maxSpeed
if desired.getMag() < 100:
speed = mapNum(desired.getMag(), 0, 100, 0, self.maxSpeed)
desired.limitMag(speed)
steer = Vector.subTwo(desired, self.vel)
steer.limitMag(self.maxForce)
return steer
def avoid(self, target):
steer = self.seek(target)
return steer.mult(Vector(-1, -1))
def randomness(self):
steer = Vector.getRndVec(-1, 1)
steer.limitMag(self.maxForce)
return steer
def rebound(self):
distance = Vector.getDis(self.pos, self.world.center)
if distance > self.world.center_dis != 0:
return self.seek(self.world.center)
else:
return Vector(0, 0)
def getVerts(self):
verts = np.zeros((4, 2), dtype=int)
bot_point = self.vel.copy()
bot_point.setMag(self.size)
top_point = bot_point.getFliped()
bot_point.div(Vector(
np.sqrt(2), np.sqrt(2))) # get sqrt 2 from a constant in math lib
perp = top_point.getPerp()
right_point = Vector.addTwo(bot_point, perp)
left_point = Vector.subTwo(bot_point, perp)
bot_point.mult(Vector(.6, .6))
verts[0, :] = Vector.addTwo(top_point, self.pos).toArr()
verts[1, :] = Vector.addTwo(right_point, self.pos).toArr()
verts[2, :] = Vector.addTwo(bot_point, self.pos).toArr()
verts[3, :] = Vector.addTwo(left_point, self.pos).toArr()
return verts
def draw(self, arr):
x, y = (int(self.pos.x), int(self.pos.y))
cv2.circle(arr, (x, y), self.size,
[mapNum(self.vel.getMag(), 0, self.maxSpeed, 51, 255)] * 3,
-1)
import Vector myVector = Vector.Vector([1, 2, 3]) print(myVector.__str__()) print(myVector.__eq__([2, 1, 2]))
def randomFlagLocation(self):
import vsrandom
if (len(self.flags)):
i = vsrandom.randrange(0,len(self.flags))
return Vector.Add((vsrandom.uniform(-20,20),vsrandom.uniform(-20,20),vsrandom.uniform(-20,20)),self.flags[i].Position())
return (0,0,0)
start += Vector((randrange(3) - 1) * Constants.GRID_SIZE, (randrange(3) - 1) * Constants.GRID_SIZE)
while(start.x >= Constants.WORLD_WIDTH - Constants.GRID_SIZE or start.y >= Constants.WORLD_HEIGHT - Constants.GRID_SIZE):
start += Vector((randrange(3) - 1) * Constants.GRID_SIZE, (randrange(3) - 1) * Constants.GRID_SIZE)
graph.placeObstacle(start, (0, 0, 0))
#################################################################################
# Main Functionality
#################################################################################
pygame.init();
screen = pygame.display.set_mode((Constants.WORLD_WIDTH, Constants.WORLD_HEIGHT))
clock = pygame.time.Clock()
sheepImage = pygame.image.load('sheep.png')
dogImage = pygame.image.load('collie.png')
bounds = Vector(Constants.WORLD_WIDTH, Constants.WORLD_HEIGHT)
# Setup the graph
graph = Graph()
# Setup the dog
dog = Player(dogImage, Vector(Constants.WORLD_WIDTH * .5, Constants.WORLD_HEIGHT * .5),
Vector(Constants.DOG_WIDTH, Constants.DOG_HEIGHT), (0, 255, 0),
Constants.DOG_SPEED, Constants.DOG_ANGULAR_SPEED)
print (dog.center)
# Setup the sheep (only 1 for now...)
herd = []
sheep = Sheep(sheepImage, Vector(randrange(int(bounds.x * .4), int(bounds.x * .6)), randrange(int(bounds.y * .6), int(bounds.y * .8))), Vector(Constants.DOG_WIDTH, Constants.DOG_HEIGHT), (0, 255, 0), Constants.SHEEP_SPEED, Constants.SHEEP_ANGULAR_SPEED)
#sheep = Sheep(sheepImage, Vector(100,200), Vector(16,32), (0,255,0), 5, 5)
herd.append(sheep)
def getshape(self):
"""Return a list of vectors giving the polygon for this turtle."""
return [
self.position + Vector(0, 5), self.position - Vector(5, 0),
self.position - Vector(0, 5), self.position + Vector(5, 0)
]
def select_next_action(self):
#Scan the radar
self._dynamic_radar_data = self._radar.scan_dynamic_obstacles(
self._gps.location())
self._radar_data = self._radar.scan(self._gps.location())
# Give the current observation to the obstacle motion predictor
self.debug_info[
'future_obstacles'] = self._obstacle_predictor.add_observation(
self._gps.location(), self._radar_data,
self._dynamic_radar_data,
self._obstacle_predictor_dynobs_getter_func)
if self._last_solution_node.data[:2] != (int(
self._gps.location()[0]), int(self._gps.location()[1])):
self._solution.insert(0, self._last_solution_node)
self._pruneAndPrepend()
if not self._rrt.hasGoal(self._targetpos, self._goalThreshold):
self._rrt = Tree(
Node((self._gps.location()[0], self._gps.location()[1],
self._time)))
qgoal = Node(
(self._targetpos[0], self._targetpos[1],
self._minTimeMultiplier *
self._minTime(self._gps.location(), self._targetpos)))
self._status = self._grow_rrt(self._rrt, qgoal,
self._goalThreshold, True)
self._extract_solution()
if self._status == 0:
#There is a valid path from robot to goal
while 0 < len(self._solution) and (
Vector.distance_between(self._gps.location(),
self._solution[0].data[:2]) < 1.5
or self._solution[0].data[2] <= self._time):
del self._solution[0]
timeDiff = self._solution[0].data[2] - self._time
#Should always be > 0
direction = Vector.degrees_between(self._gps.location(),
self._solution[0].data[:2])
dist = min(
self._maxstepsize,
Vector.distance_between(self._gps.location(),
self._solution[0].data[:2]) / timeDiff)
self.debug_info["path"] = self._solution
self._last_solution_node = self._solution[0]
self._time += 1
if self._status == 1:
#No valid path found
self._has_given_up = True
dist = 0
direction = np.random.uniform(low=0, high=360)
if self._status == 2:
#Robot or goal is inside dynamic obstacle
dist = 0
direction = np.random.uniform(low=0, high=360)
return RobotControlInput(dist, direction)
def createConvexPolygon(s):
v = VectorInput.getVectorList(s)
if len(v) < 3:
raise Exception("Less than 3 vertices")
Vector.sortVector(v)
return ConvexPolygon(v)
def motion(self, event):
drag = Vector(event.x, event.y)
if self.dragging:
self.dragging.position = self.start + drag - self.dragstart
self.update(self.dragging)
from Tkinter import * # Import everything from Tkinter from Arena import Arena # Import our Arena from Turtle import Turtle # Import our Turtle from Vector import * # Import everything from our Vector Turtle.m = 50.0 # Scaling factor Turtle.origin = Vector(400, 300) from Statue import * from Mouse import * from Cat import * statue = Statue(Turtle.origin + Vector(0, 0), 0) mouse = Mouse(Turtle.origin + Vector(0, -Turtle.m).rotate(40), 0) cat = Cat(Turtle.origin + Vector(0, -4 * Turtle.m).rotate(200), 0, mouse) tk = Tk() # Create a Tk top-level widget arena = Arena(tk, 800, 600) # Create an Arena widget, arena arena.pack() # Tell arena to pack itself on screen arena.add(statue) # Add a very simple, statue arena.add(mouse) # Add a green mouse centered at the base of the statue arena.add(cat) # Add a red cat tk.mainloop() # Enter the Tkinter event loop
import os from Vector import * # FIXED CONSTANTS ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) VIRTUAL_SIZE = Vector(1280, 720) # CHANGEABLE CONSTANTS SAMPLES = 4 # anti-aliasing
def testPerimeter(self):
c = Vector.Vector([0, 0])
r = 1
o = Circle.Circle(c, r)
self.assertEqual(o.perimeter(), 2 * math.pi)
# Accepts response id as system argument
import Vector
import ConnectInfo
import sys
response_id = str(sys.argv[1])
db = ConnectInfo.sql()
cur = db[0]
conn = db[1]
sql = "select Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10, Q11, Q12, Q13, Q14, Q15, Q16, Q17, Q18, Q19, Q20 from User_Response where User_Response_ID=" + response_id
answerssql = cur.execute(sql)
answers = cur.fetchall()
qanswers = map(int, answers[0])
recommendation = Vector.distcheck(qanswers)
#print ("Your recommended major is: " + recommendation[0])
cur.execute("UPDATE User_Response SET Rec_Major = '" + recommendation[0] +
"' WHERE User_Response_ID = " + response_id)
def drawCubo(self): CUBO = [ v.Vector3D( self.radius + self.center.x, self.radius + self.center.y, self.radius + self.center.z), v.Vector3D(-self.radius + self.center.x, self.radius + self.center.y, self.radius + self.center.z), v.Vector3D(-self.radius + self.center.x,-self.radius + self.center.y, self.radius + self.center.z), v.Vector3D( self.radius + self.center.x,-self.radius + self.center.y, self.radius + self.center.z), v.Vector3D( self.radius + self.center.x, self.radius + self.center.y,-self.radius + self.center.z), v.Vector3D(-self.radius + self.center.x, self.radius + self.center.y,-self.radius + self.center.z), v.Vector3D(-self.radius + self.center.x,-self.radius + self.center.y,-self.radius + self.center.z), v.Vector3D( self.radius + self.center.x,-self.radius + self.center.y,-self.radius + self.center.z) ] #for i in range(0, 8): # CUBO[i] = CUBO[i].inversion(3) self.setCube() glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE) glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[0].x, CUBO[0].y, CUBO[0].z) glVertex3f(CUBO[1].x, CUBO[1].y, CUBO[1].z) glColor3f(255, 0, 0) glVertex3f(CUBO[2].x, CUBO[2].y, CUBO[2].z) glVertex3f(CUBO[3].x, CUBO[3].y, CUBO[3].z) glEnd() glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[7].x, CUBO[7].y, CUBO[7].z) glVertex3f(CUBO[6].x, CUBO[6].y, CUBO[6].z) glColor3f(255, 0, 0) glVertex3f(CUBO[5].x, CUBO[5].y, CUBO[5].z) glVertex3f(CUBO[4].x, CUBO[4].y, CUBO[4].z) glEnd() glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[0].x, CUBO[0].y, CUBO[0].z) glVertex3f(CUBO[3].x, CUBO[3].y, CUBO[3].z) glColor3f(255, 0, 0) glVertex3f(CUBO[7].x, CUBO[7].y, CUBO[7].z) glVertex3f(CUBO[4].x, CUBO[4].y, CUBO[4].z) glEnd() glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[1].x, CUBO[1].y, CUBO[1].z) glVertex3f(CUBO[5].x, CUBO[5].y, CUBO[5].z) glColor3f(255, 0, 0) glVertex3f(CUBO[6].x, CUBO[6].y, CUBO[6].z) glVertex3f(CUBO[2].x, CUBO[2].y, CUBO[2].z) glEnd() glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[2].x, CUBO[2].y, CUBO[2].z) glVertex3f(CUBO[6].x, CUBO[6].y, CUBO[6].z) glColor3f(255, 0, 0) glVertex3f(CUBO[7].x, CUBO[7].y, CUBO[7].z) glVertex3f(CUBO[3].x, CUBO[3].y, CUBO[3].z) glEnd() glFrontFace(GL_CCW); glEnable(GL_CULL_FACE) glCullFace(GL_BACK) glBegin(GL_POLYGON) #glNormal3d(normal0, normal1, normal2) glColor3f(0, 0, 255) glVertex3f(CUBO[1].x, CUBO[1].y, CUBO[1].z) glVertex3f(CUBO[0].x, CUBO[0].y, CUBO[0].z) glColor3f(255, 0, 0) glVertex3f(CUBO[4].x, CUBO[4].y, CUBO[4].z) glVertex3f(CUBO[5].x, CUBO[5].y, CUBO[5].z) glEnd() #c = cube(v.Vector3D(0, 0, 0), 1) #c.drawCube()
def toonear (self,vec,un):
vec= Vector.Sub(un.Position(),vec)
if (Vector.Dot(vec,vec)<1000):
return True
return False
def avoid(self, target):
steer = self.seek(target)
return steer.mult(Vector(-1, -1))
from Player2 import *
from Interaction import *
from drawPlatforms import *
from Player import *
from LevelBackground import *
from Menu import *
from Level import *
from pygame import *
mixer.init()
from pygame import *
player1 = Player2(Vector(400, 400), "https://i.imgur.com/2cnk4Yx.png", 496, 1160, 10, 4, 'w', 'a', 's', 'd', 'up',
'left', 'right', 10, 3)
platforms = drawPlatforms("hard", 7)
lv1 = LevelBackground('https://i.imgur.com/Q7tBgIc.png')
interactions = []
addedInteractions = False
def draw(canvas):
global interactions, addedInteractions
lv1.update(canvas)
platforms.draw(canvas)
if not addedInteractions:
for i in range(len(platforms.getCoords())):
def testCircleException(self):
c = Vector.Vector([0, 0])
r = -1
self.assertRaisesRegex(Exception, "Radius less than zero",
Circle.Circle, c, r)
def __init__(self, newPosit,newN, newMaterial, objNum, t):
self.locationVector = Vector(newPosit.x, newPosit.y, newPosit.z)
self.n = newN
self.material = newMaterial
self.objNum = objNum
self.t = t
def proyVec(self, proy):
p = self.scale(proy / (proy - self.w))
return v3d.Vector3D(p.x, p.y, p.z)
winWidth, winHeight = 700, 700
pygame.init()
win = pygame.display.set_mode((winWidth, winHeight))
pygame.display.set_caption("Simulator")
particles = []
f = Field.Field(0, 0, 700, 700)
for i in range(f.dim.x):
for j in range(f.dim.y):
x = i - 350
y = j - 350
dx = y / 30
dy = -(x**2) / 2000
f.setVectors(i, j, Vector.Vector(dx, dy))
for i in range(300):
p = Particle.Particle(random.randint(300, 400), random.randint(300, 400),
0, 0, 5, (255, 0, 0), win)
particles.append(p)
running = True
while running:
pygame.time.delay(10)
win.fill(0)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
def _minTime(self, sPoint, gPoint):
return np.ceil(
Vector.distance_between(sPoint, gPoint) / self._robot_speed)
def rebound(self):
distance = Vector.getDis(self.pos, self.world.center)
if distance > self.world.center_dis != 0:
return self.seek(self.world.center)
else:
return Vector(0, 0)
def bounds(self):
return Vector(width, height)
import math
import matplotlib.pyplot as plt
import numpy as np
from Vector import *
from RK4 import RK4, evaluateODE
M1 = 1.899 * 10**29; M2 = 1.989 * 10**30; G = 6.6742 * 10**(-11);
R = 778.3 * 10**9; T = 3.743 * 10**8;
r1 = Vector([M2 * R / (M1 + M2), 0, 0]); r2 = Vector([-M1 * R / (M1 + M2), 0, 0]);
O = math.sqrt(G * (M1 + M2) / (R**3))
alpha = math.pi / 8
rInit = R * Vector([(M2 - M1)/(M1 + M2) * math.cos(alpha), math.sin(alpha), 0])
def func(vec, t):
r = Vector([vec[0], vec[2], 0])
acc = -G*M1/Vector.magnitude(r-r1)**3 * (r-r1) - G*M2/Vector.magnitude(r-r2)**3 * (r-r2) + 2*O*Vector([vec[3], -vec[1], 0]) + O**2 * r
return Vector([vec[1], acc[0], vec[3], acc[1]])
N = 2*T; h = T / 1000;
xList = []; yList = [];
vecInit = Vector([rInit[0], 0, rInit[1], 0])
vecList = evaluateODE(vecInit, h, func, N)
for v in vecList:
xList.append(v[0]); yList.append(v[2]);
plt.plot(xList, yList); plt.xlabel("X"); plt.ylabel("Y"); plt.show();
from Vector import * v1 = Vector(2,10) v2 = Vector(5,-2) print v1 + v2
def func(vec, t):
r = Vector([vec[0], vec[2], 0])
acc = -G*M1/Vector.magnitude(r-r1)**3 * (r-r1) - G*M2/Vector.magnitude(r-r2)**3 * (r-r2) + 2*O*Vector([vec[3], -vec[1], 0]) + O**2 * r
return Vector([vec[1], acc[0], vec[3], acc[1]])
def __init__(self, pos, heading, color):
self.pos = Vector().set(pos)
self.heading = Vector().set(heading)
self.color = Vector().set(color)
