def postprocess(self):
"""
Some operations on parsed data
"""
log.debug('%i geometries found' % (len(self.geoms)))
if self.vector:
log.debug('Vectors found')
#self.geoms.consistencyCheck()
# import conversion units
if self.geoms[-1].to_kcalmol:
self.to_kcalmol = self.geoms[-1].to_kcalmol
else:
self.to_kcalmol = 1.
# Do we have extended data?
if 'e' in self.geoms.props:
if 'x' in self.geoms.props:
self.scan = Geometry.IRC(other=self.geoms)
log.debug('IRC plot will be shown')
else:
self.scan = Geometry.Scan(other=self.geoms)
log.debug('Scan plot will be shown')
log.debug('XYZ file parsed successfully')
def addBox(self, box, colour=None):
if not Visualiser.VISUALISER_ON:
return
if isinstance(box, geo.Box):
if colour == None:
colour = visual.color.red
org = geo.transform_point(box.origin, box.transform)
ext = geo.transform_point(box.extent, box.transform)
print "Visualiser: box origin=%s, extent=%s" % (str(org), str(ext))
size = np.abs(ext - org)
pos = org + 0.5 * size
print "Visualiser: box position=%s, size=%s" % (str(pos),
str(size))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print "colour,", colour
if colour == [0, 0, 0]:
visual.box(pos=pos,
size=size,
opacity=0.3,
material=visual.materials.plastic)
else:
visual.box(pos=pos,
size=size,
color=geo.norm(colour),
opacity=0.5)
def get_obsflags(self, location, flag_types=0xFFFFFFFF):
flags = 0x00000000
if flag_types & (ObsFlag.DYNAMIC_OBSTACLE | ObsFlag.ANY_OBSTACLE):
for obs in self.dynamic_obstacles:
vec = np.subtract(location, obs.coordinate)
if (obs.shape == 1 and np.dot(vec, vec) < obs.radius*obs.radius) \
or (obs.shape == 2 and Geometry.point_inside_rectangle([obs.coordinate, obs.size], location)) \
or (obs.shape == 3 and np.dot(vec, vec) < max(obs.width, obs.height)**2/4 and Geometry.point_inside_ellipse(obs.coordinate, obs.width, obs.height, np.arctan2(obs.get_velocity_vector()[1], obs.get_velocity_vector()[0]), location)) \
or (obs.shape == 4 and obs.polygon.contains_point(location)):
flags |= ObsFlag.DYNAMIC_OBSTACLE
break
if flag_types & (ObsFlag.STATIC_OBSTACLE | ObsFlag.ANY_OBSTACLE):
for obs in self.static_obstacles:
vec = np.subtract(location, obs.coordinate)
if (obs.shape == 1 and np.dot(vec, vec) < obs.radius*obs.radius) \
or (obs.shape == 2 and Geometry.point_inside_rectangle([obs.coordinate, obs.size], location)) \
or (obs.shape == 3 and np.dot(vec, vec) < max(obs.width, obs.height)**2/4 and Geometry.point_inside_ellipse(obs.coordinate, obs.width, obs.height, np.arctan2(obs.get_velocity_vector()[1], obs.get_velocity_vector()[0]), location)) \
or (obs.shape == 4 and obs.polygon.contains_point(location)):
flags |= ObsFlag.STATIC_OBSTACLE
break
if flags & (ObsFlag.DYNAMIC_OBSTACLE | ObsFlag.STATIC_OBSTACLE):
flags |= ObsFlag.ANY_OBSTACLE
# Make sure to only return the requested flag types
flags = flags & flag_types
return flags
def addBox(self, box, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(box, geo.Box):
if colour == None:
colour = visual.color.red
if material is None:
material = visual.materials.plastic
org = geo.transform_point(box.origin, box.transform)
ext = geo.transform_point(box.extent, box.transform)
print "Visualiser: box origin=%s, extent=%s" % (str(org), str(ext))
size = np.abs(ext - org)
pos = org + 0.5 * size
print "Visualiser: box position=%s, size=%s" % (str(pos),
str(size))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print "colour,", colour
if np.allclose(np.array(colour), np.array([0, 0, 0])):
visual.box(pos=pos,
size=size,
material=material,
opacity=opacity)
else:
visual.box(pos=pos,
size=size,
color=colour,
materials=material,
opacity=opacity)
def draw(self, Canvas, line):
t_size = 8 / Canvas.Scale
point = self.pos
## Make the T shape with lines
downPoint = (point[0] , point[1]-t_size/2)
upPoint = (point[0], point[1]+t_size)
rightPoint = (point[0]+t_size, point[1]+t_size)
leftPoint = (point[0]-t_size, point[1]+t_size)
## rotate the T shape to always be normal to the edge
theta = Geom.angleFromXaxis(line)
lines = [leftPoint, rightPoint , upPoint, downPoint]
lines = Geom.rotatePointList(lines, theta, point)
Canvas.AddLine(
[lines[0], lines[1]],
LineWidth=4,
LineColor="BLUE"
)
Canvas.AddLine(
[lines[2], lines[3]],
LineWidth=4,
LineColor="BLUE"
)
def test_line():
expected = 1, 2
to_point = geo.point(1, 1)
from_point = geo.point(4, 4)
line = geo.Line(from_point, to_point)
actual = line.tpfp()
print_test_results(line.tpfp, expected, actual)
def kinect_to_cartesian(kinect_pos, calib):
top_dist = Geometry.distFromPointToLine(kinect_pos, calib.ul, calib.ur)
bot_dist = Geometry.distFromPointToLine(kinect_pos, calib.ul, calib.ur)
left_dist = Geometry.distFromPointToLine(kinect_pos, calib.ul, calib.ur)
right_dist = Geometry.distFromPointToLine(kinect_pos, calib.ul, calib.ur)
h = []
def Update(self, ShapeObj1, ShapeObj2):
if ShapeObj1 == None or ShapeObj2 == None:
return
if ShapeObj2.isLine():
tmp = ShapeObj1
ShapeObj1 = ShapeObj2
ShapeObj2 = tmp
if ShapeObj1.isRing() == False:
self.m_start = Geometry.GetMidPoint(ShapeObj1.m_start,
ShapeObj1.m_end)
else:
pathPaint = QPainterPath()
startPoint = QPoint(
ShapeObj1.m_start.x() +
(ShapeObj1.m_end.x() - ShapeObj1.m_start.x()) / 4,
ShapeObj1.m_start.y())
end = QPoint(
ShapeObj1.m_start.x() +
(ShapeObj1.m_end.x() - ShapeObj1.m_start.x()) / 4 * 3,
ShapeObj1.m_start.y())
startPoint += QPoint(
0.0, (ShapeObj1.m_start.y() - ShapeObj1.m_end.y()) / 2)
endPoint = startPoint + QPoint(end.x() - startPoint.x(), 0)
self.m_start = Geometry.GetMidPoint(startPoint, endPoint)
lMPoint = ShapeObj2.GetConnerPoints()
nMinLen = 1000000
nLen = len(lMPoint)
for i in range(nLen):
nDis = Geometry.GetDistance(lMPoint[i], self.m_start)
if nDis < nMinLen:
nMinLen = nDis
self.m_end = lMPoint[i]
return
def __init__(self, name, origin):
self.name = name
if not isinstance(origin, Base.Vector):
raise RuntimeError("origin is not a Vector!")
self.origin = origin
self.center = Engine(name + "_center", origin, size='E24')
self.centermount = BodyTube(name+"_centermount",\
origin.add(Base.Vector(0,0,6.35)),\
size='BT-50',length=95)
self.centermountlowerring = EngineMountRing(\
name+"_centermountlowerring",\
origin.add(Base.Vector(0,0,50.8-(95-(70 + 6.35))+6.35)),\
enginesize='E24',tubesize='BT-55')
self.centermountupperring = EngineMountRing(\
name+"_centermountlowerring",\
origin.add(Base.Vector(0,0,95)),\
enginesize='E24',tubesize='BT-55')
self.stage2 = BodyTube(name+"_stage2",\
origin.add(Base.Vector(0,0,6.35)),\
size='BT-55',length=400)
self.fin1 = FinType1(self.name+"_fin1",\
origin.add(Geometry.pointXdeltaatang(60,17,6.35+70)),\
orient=60,height=70,angle=30,length=200)
self.fin2 = FinType1(self.name+"_fin2",\
origin.add(Geometry.pointXdeltaatang(180,17,6.35+70)),\
orient=180,height=70,angle=30,length=200)
self.fin3 = FinType1(self.name+"_fin3",\
origin.add(Geometry.pointXdeltaatang(300,17,6.35+70)),\
orient=300,height=70,angle=30,length=200)
def UpdateLigandAnchorPoint(self):
try:
if self.Translation:
index = int(float(self.Line[self.colNo:self.colNo+10]))
coordX = self.top.GridVertex[index][0] # The atom X coordinate
coordY = self.top.GridVertex[index][1] # The atom Y coordinate
coordZ = self.top.GridVertex[index][2] # The atom Z coordinate
pointA = [coordX, coordY, coordZ]
pointB = [self.top.OriX[0], self.top.OriX[1], self.top.OriX[2]]
pointC = [self.top.Ori[0], self.top.Ori[1], self.top.Ori[2]]
pointD = [self.top.OriY[0], self.top.OriY[1], self.top.OriY[2]]
self.top.DisAngDih[self.top.VarAtoms[0]][0] = Geometry.distance(pointA, pointB)
self.top.DisAngDih[self.top.VarAtoms[0]][1] = Geometry.angle(pointA, pointB, pointC)
self.top.DisAngDih[self.top.VarAtoms[0]][2] = Geometry.dihedralAngle(pointA, pointB, pointC, pointD)
self.colNo += 11
if self.Rotation:
self.top.DisAngDih[self.top.VarAtoms[1]][1] = float(self.Line[self.colNo:self.colNo+10])
self.top.DisAngDih[self.top.VarAtoms[1]][2] = float(self.Line[self.colNo+11:self.colNo+21])
self.top.DisAngDih[self.top.VarAtoms[2]][2] = float(self.Line[self.colNo+22:self.colNo+32])
self.colNo += 33
except:
self.CriticalError(" Could not update ligand anchor point")
return 1
return 0
def do_mouse_stuff(self, hand): #Take a hand and use it as a mouse
hand_normal_direction = Geometry.to_vector(hand.palm_normal)
hand_direction = Geometry.to_vector(hand.direction)
roll = hand_normal_direction.roll()
pitch = hand_normal_direction.pitch()
mouse_velocity = self.convert_angles_to_mouse_velocity(roll, pitch)
self.cursor.move(mouse_velocity[0], mouse_velocity[1])
def UpdateLigandAnchorPoint(self):
try:
if self.Translation:
index = int(float(self.Line[self.colNo:self.colNo+10]))
coordX = self.top.GridVertex[index][0] # The atom X coordinate
coordY = self.top.GridVertex[index][1] # The atom Y coordinate
coordZ = self.top.GridVertex[index][2] # The atom Z coordinate
pointA = [coordX, coordY, coordZ]
pointB = [self.top.OriX[0], self.top.OriX[1], self.top.OriX[2]]
pointC = [self.top.Ori[0], self.top.Ori[1], self.top.Ori[2]]
pointD = [self.top.OriY[0], self.top.OriY[1], self.top.OriY[2]]
self.top.DisAngDih[self.top.VarAtoms[0]][0] = Geometry.distance(pointA, pointB)
self.top.DisAngDih[self.top.VarAtoms[0]][1] = Geometry.angle(pointA, pointB, pointC)
self.top.DisAngDih[self.top.VarAtoms[0]][2] = Geometry.dihedralAngle(pointA, pointB, pointC, pointD)
self.colNo += 11
if self.Rotation:
self.top.DisAngDih[self.top.VarAtoms[1]][1] = float(self.Line[self.colNo:self.colNo+10])
self.top.DisAngDih[self.top.VarAtoms[1]][2] = float(self.Line[self.colNo+11:self.colNo+21])
self.top.DisAngDih[self.top.VarAtoms[2]][2] = float(self.Line[self.colNo+22:self.colNo+32])
self.colNo += 33
except:
self.CriticalError(" Could not update ligand anchor point")
return 1
return 0
def polygon_is_collision_speed_test():
'''
Determine how long it takes for the concave capable polygon collision check
call takes
'''
print('---------- Polygon Collision checking speed test ----------')
poly1 = geom.Polygon()
poly1.unit_circle(40,1.)
poly1.translate(3.,3.)
poly2 = geom.Polygon()
poly2.unit_circle(40,1.)
poly2.translate(3.2,3.2)
num_players = 1.
num_obstacles = 2.
fps_multiplier = 1./((4*num_players)+(2*num_obstacles))
tic = time.time()
collis_res = geom.polygon_is_collision(poly1,poly2)
toc = time.time()
print(f'Collision checking took (s): {toc-tic}')
print(f'Results: {collis_res.any()}')
try:
print(f'FPS: {(1./(toc-tic))*fps_multiplier}')
except:
print("Couldn't compute FPS...")
geom.polygon_plot(poly1,poly2,lim=[0,15,0,15],title=f'Collision Result: {collis_res}')
def runningLoop(self):
mb = pygame.mouse.get_pressed()
k = pygame.key.get_pressed()
for e in pygame.event.get():
if e.type == pygame.QUIT:
self.running = False
if self.delay == 0:
if mb[0] == 1:
self.cam.screen.rotateAboutY(0.01)
self.delay = 1
if mb[2] == 1:
self.cam.screen.rotateAboutY(-0.01)
self.delay = 1
if k[pygame.K_w]:
self.cam.screen.translate(Geometry.AVector3(1, 0, 0))
self.delay = 1
if k[pygame.K_s]:
self.cam.screen.translate(Geometry.AVector3(-1, 0, 0))
self.delay = 1
if k[pygame.K_a]:
self.cam.screen.translate(Geometry.AVector3(0, 0, 1))
self.delay = 1
if k[pygame.K_d]:
self.cam.screen.translate(Geometry.AVector3(0, 0, -1))
self.delay = 1
if self.delay > 0:
self.delay -= 1
self.cam.draw()
self.screen.blit(self.cam.canvas, (0, 0))
pygame.display.flip()
def get_dynobs_at_angle(self, center, angle): ang_in_radians = angle * np.pi / 180.0; endpoint = center + Vector.unitVectorFromAngle(ang_in_radians) * self.radius; min_dist = -1; closest_dynobs = None; for dynobs in self._env.dynamic_obstacles: if dynobs.shape == 1: inters = Geometry.circle_line_intersection(dynobs.coordinate, dynobs.radius, [center, endpoint]); elif dynobs.shape == 2: inters = Geometry.rectangle_line_intersection([dynobs.coordinate, np.array(dynobs.size)], [center, endpoint]); if len(inters) == 0: continue; inters_rel = np.array(inters) - center; dist = 1 if len(inters) == 1: dist = Vector.magnitudeOf(inters_rel[0]); else: if np.dot(inters_rel[0], inters_rel[0]) < np.dot(inters_rel[1], inters_rel[1]): dist = Vector.magnitudeOf(inters_rel[0]); else: dist = Vector.magnitudeOf(inters_rel[1]); if dist < min_dist or min_dist < 0: min_dist = dist; closest_dynobs = dynobs return closest_dynobs;
def do_mouse_stuff(self, hand): #Take a hand and use it as a mouse
hand_normal_direction = Geometry.to_vector(hand.palm_normal)
hand_direction = Geometry.to_vector(hand.direction)
roll = hand_normal_direction.roll()
pitch = hand_normal_direction.pitch()
mouse_velocity = self.convert_angles_to_mouse_velocity(roll, pitch)
self.cursor.move(mouse_velocity[0], mouse_velocity[1])
def getCorner(self, p):
if self.isRing() == False:
lPoint = []
lPoint.append(self.m_start)
lPoint.append(self.m_end)
for i in range(len(lPoint)):
if Geometry.getDistance(lPoint[i], p) <= 10:
self.m_curConner = i
return i
self.m_curConner = -1
else:
lPoint = []
startPoint = QPoint(
self.m_start.x() + (self.m_end.x() - self.m_start.x()) / 4,
self.m_start.y())
end = QPoint(
self.m_start.x() + (self.m_end.x() - self.m_start.x()) / 4 * 3,
self.m_start.y())
lPoint.append(startPoint)
lPoint.append(end)
for i in range(len(lPoint)):
if Geometry.getDistance(lPoint[i], p) <= 10:
self.m_curConner = i
return i
self.m_curConner = -1
return -1
def do_scroll_continuous(self, hand):
hand_normal_direction = Geometry.to_vector(hand.palm_normal)
hand_direction = Geometry.to_vector(hand.direction)
roll = hand_normal_direction.roll()
pitch = hand_normal_direction.pitch()
velocity = self.convert_angles_to_mouse_velocity(roll, pitch) * 100
self.cursor.scroll(velocity[0], velocity[1])
def paint(self, painter):
self.setPainter(painter)
lPoint = []
lPoint.append(self.m_start)
lPoint.append(QPoint(self.m_start.x(), self.m_end.y()))
lPoint.append(self.m_end)
lPoint.append(QPoint(self.m_end.x(), self.m_start.y()))
m1 = Geometry.GetMidPoint(lPoint[0], lPoint[1])
m2 = Geometry.GetMidPoint(lPoint[1], lPoint[2])
m3 = Geometry.GetMidPoint(lPoint[2], lPoint[3])
m4 = Geometry.GetMidPoint(lPoint[3], lPoint[0])
lMPoint = [m1, m2, m3, m4]
path = QPainterPath()
path.moveTo(m1)
path.lineTo(m2)
path.lineTo(m3)
path.lineTo(m4)
path.lineTo(m1)
painter.drawPath(path)
if self.hasCorner() != -1:
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor(0, 255, 0))
painter.setPen(pen)
painter.drawEllipse(lMPoint[self.m_curConner], 5, 5)
def draw(self, Canvas, line):
r_size = 10 / Canvas.Scale
point = self.pos
rightPoint = (point[0] - r_size, point[1])
leftPoint = (point[0] + r_size, point[1])
upRightPoint = (rightPoint[0], rightPoint[1]+ r_size)
downRightPoint = (rightPoint[0], rightPoint[1]-r_size)
upLeftPoint = (leftPoint[0], leftPoint[1]+r_size)
downLeftPoint = (leftPoint[0], leftPoint[1]-r_size)
theta = Geom.angleFromXaxis(line)
firstTriangle = [point, upRightPoint, downRightPoint]
secondTriangle = [point, upLeftPoint, downLeftPoint]
firstTriangle = Geom.rotatePointList(firstTriangle, theta, point)
secondTriangle = Geom.rotatePointList(secondTriangle, theta, point)
Canvas.AddPolygon(
firstTriangle,
LineWidth=1,
LineColor="BLUE",
FillColor="BLUE",
)
Canvas.AddPolygon(
secondTriangle,
LineWidth=1,
LineColor="BLUE",
FillColor="BLUE",
)
def __init__(self, name, origin):
self.name = name
if not isinstance(origin, Base.Vector):
raise RuntimeError("origin is not a Vector!")
self.origin = origin
XNorm = Base.Vector(1, 0, 0)
BoardExtrude = Base.Vector(self._boardThick, 0, 0)
boardCorner = origin.add(Base.Vector(-self._boardThick/2.0,\
self._boardWidth/2.0,\
0))
#print("*** ComputerAssembly(): origin is ",origin.x,origin.y,origin.z,file=sys.__stderr__)
#print("*** ComputerAssembly(): boardCorner is ",boardCorner.x,boardCorner.y,boardCorner.z,file=sys.__stderr__)
self.telemetrypcb = Part.makePlane(self._boardLength, self._boardWidth,
boardCorner,
XNorm).extrude(BoardExtrude)
ttgocp = boardCorner.add(Base.Vector(5.08, -3.81, 128.27))
self.ttgo = Part.makePlane(45.72, 25.4, ttgocp,
XNorm).extrude(BoardExtrude)
adxl345cp = boardCorner.add(Base.Vector(5.08, -5.08, 92.71))
self.adafruit_adxl345 = Part.makePlane(25.4, 20.32, adxl345cp,
XNorm).extrude(BoardExtrude)
mpl3115a2cp = boardCorner.add(Base.Vector(5.08, -5.08, 68.5))
self.adafruit_mpl3115a2 = Part.makePlane(20.32, 17.7, mpl3115a2cp,
XNorm).extrude(BoardExtrude)
DS3231_rtccp = boardCorner.add(Base.Vector(5.08, -5.08, 40.54))
self.adafruit_DS3231_rtc = Part.makePlane(22.05, 17.7, DS3231_rtccp,
XNorm).extrude(BoardExtrude)
self.topdisk = Part.Face(
Part.Wire(
Part.makeCircle(33.0 / 2, origin.add(Base.Vector(
0, 0,
177.8))))).extrude(Base.Vector(0, 0, (1.0 / 8.0) * 25.4))
gradiusX = 26.5 / 2
gbottom = -24.5
gheight = 177.8 + 12 + 37.5
gradius = (1.0 / 8.0) * 25.4
self.guide1 = Part.Face(
Part.Wire(
Part.makeCircle(
gradius,
origin.add(Geometry.pointXdeltaatang(
90, gradiusX,
gbottom))))).extrude(Base.Vector(0, 0, gheight))
self.guide2 = Part.Face(
Part.Wire(
Part.makeCircle(
gradius,
origin.add(
Geometry.pointXdeltaatang(
210, gradiusX,
gbottom))))).extrude(Base.Vector(0, 0, gheight))
self.guide3 = Part.Face(
Part.Wire(
Part.makeCircle(
gradius,
origin.add(
Geometry.pointXdeltaatang(
330, gradiusX,
gbottom))))).extrude(Base.Vector(0, 0, gheight))
def addPolygon(self, polygon, colour=None):
if not Visualiser.VISUALISER_ON:
return
if isinstance(polygon, geo.Polygon):
if colour == None:
visual.convex(pos=polygon.pts, color=geo.norm([0.1,0.1,0.1]), material=visual.materials.plastic)
else:
visual.convex(pos=convex.points, color=geo.norm(colour), opacity=0.5)
def addPolygon(self, polygon, colour=None, opacity=1., material=visual.materials.plastic):
if not Visualiser.VISUALISER_ON:
return
if isinstance(polygon, geo.Polygon):
if colour == None:
visual.convex(pos=polygon.pts, color=geo.norm([0.1,0.1,0.1]), material=material)
else:
visual.convex(pos=polygon.pts, color=geo.norm(colour), material=material)
def equalsTo(self, b):
sb = self.box
bb = b.box
dim = self.dp.samplingDimension
efact = 0.9
retval = Geometry.inside(sb, bb, efact, dim) and Geometry.inside(
bb, sb, efact, dim)
return retval
def __init__(self):
self.running = True
self.screen = pygame.display.set_mode((600, 480))
self.objects = [SL.Cube(0, 0, 0, 100), SL.Cube(100, 0, 0, 50)]
canvas = Geometry.VPlane(Geometry.AVector3(1, 0, 1),
Geometry.AVector3(0, 1, 0),
Geometry.Point(0, 0, 0))
self.cam = Camera(canvas, 150, 480, 600, self.objects)
self.delay = 0
def make_accepting(self, state):
print("Accept Fired")
is_accepting = self.parser.add_accepting(state)
if is_accepting:
state.accept_button.configure(bg=ACCEPTING)
else:
state.accept_button.configure(bg=NONE)
is_entry = self.parser.is_entry(state)
Geometry.make_accepting(self.canvas_window, state, is_accepting, is_entry)
def test_Line():
fromPoint = geo.Point(1, 1)
toPoint = geo.Point(4, 5)
line1 = geo.Line(fromPoint, toPoint)
expected = 5
desc = "Returns line length."
actual = line1.length
print_test_results(geo.func, desc, expected, actual)
def main(X,i, L,Lf1,Lf2,Lf3,d_lg,d_ztail, d_ytail,S_x, W, t_st,h_st,w_st, ):
t_s = X[:,0][i]
R = X[:,1][i]
t_f = X[:,2][i]
h_f = X[:, 3][i]
n_s = int(X[:, 4][i])
y_f = R-h_f #y-loc of floor if origin if circle center
gamma_f = np.arcsin(y_f/R) #angle between x-axis and floor
theta_f = np.pi - 2*gamma_f #angle of sector with floor
A_II = (R**2/2)*(theta_f - np.sin(theta_f)) # Area Cell II
A_I = (np.pi*R**2) - A_II #Area Cell I
w_f = Geometry.floor_width(R, h_f)
stringer_area = t_st*(h_st + w_st)
#Computing q and S_x taking into account the safety factor
safetyfactor = 1.5
q = W*3*9.81*safetyfactor/L
S_x = S_x*safetyfactor
#Calculating Geometrical Properties
#Geometry.idealization(R, n_s, t_st, h_st, w_st, t_f, h_f, t_s)
x_bar, y_bar = Geometry.centroid(R, h_f, t_f, t_s, n_s, t_st, h_st, w_st)
floor_Ixx, fuselage_Ixx, stringer_Ixx = Geometry.MOIxx(x_bar, y_bar, stringer_area, R, h_f, t_f, t_s, n_s, t_st, h_st, w_st, w_f)
floor_Iyy, fuselage_Iyy, stringer_Iyy = Geometry.MOIyy(x_bar, y_bar, stringer_area, R, h_f, t_f, t_s, n_s, t_st, h_st, w_st, w_f)
Ixx_total = floor_Ixx+fuselage_Ixx+stringer_Ixx
Iyy_total = floor_Iyy+fuselage_Iyy+stringer_Iyy
Forces = reac.ReactionsFunction(L,Lf1,Lf2,Lf3,d_lg,d_ztail,d_ytail,S_x,q)
zlocation = 10
number_booms = 200
position_of_booms_total = booms_angle, booms_distance, booms_position = reac.PositionofBooms(number_booms, zlocation,
Forces, Ixx_total,
Iyy_total)
booms_area = reac.AreaBoom(booms_angle, zlocation, Ixx_total, Iyy_total, booms_distance)
delta_T, q1, q2 = tors.deflect_T(1, A_I, A_II, position_of_booms_total, booms_area, t_s, t_f, gamma_f)
J = tors.J(1, delta_T)
Mx = reac.Momentx(zlocation, Forces)
Sy = reac.Sheary(zlocation, Forces)
My = reac.Momenty(zlocation, Forces)
Sx = reac.Shearx(zlocation, Forces)
T = reac.Torque(zlocation, Forces)
# Shear
delta_S, q1_s, q2_s = tors.shearflowsb(Sx, Sy, Ixx_total, Iyy_total, A_I, A_II, booms_area, position_of_booms_total, t_s, t_f, y_f, gamma_f)
delta_Tf, q1_T, q2_T = tors.deflect_T(T, A_I, A_II, position_of_booms_total, booms_area, t_s, t_f, gamma_f)
sigma_b = tors.simga_b(Mx, My, Ixx_total, Iyy_total, position_of_booms_total, booms_area, gamma_f)
vonMises = tors.vonMises(q1_s, q2_s, q1_T, q2_T, sigma_b, t_s, t_f)
mean = np.mean(vonMises/10)
return mean
def make_accepting(self, state):
print("Accept Fired")
is_accepting = self.parser.add_accepting(state)
if is_accepting:
state.accept_button.configure(bg=ACCEPTING)
else:
state.accept_button.configure(bg=NONE)
is_entry = self.parser.is_entry(state)
Geometry.make_accepting(self.canvas_window, state, is_accepting,
is_entry)
def addPolygon(self, polygon, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(polygon, geo.Polygon):
if material is None:
material = visual.materials.plastic
if colour == None:
visual.convex(pos=polygon.pts, color=geo.norm([0.1,0.1,0.1]), material=material)
else:
visual.convex(pos=polygon.pts, color=geo.norm(colour), material=material)
def loadJsoninGlobalVariable():
global intrinsic
intrinsic = objetintrinsic(FileManager.Load("json_in/intrinsics.json"))
Counter_select.setIntrinsicParam(intrinsic)
Geometry.setIntrinsicParam(intrinsic)
Scene3D.setIntrinsicParam(intrinsic)
global annotation_file
annotation_file = FileManager.Load("json_in/annotations.json")
InfoFromAnnotation.setJson(annotation_file)
FileManager.setJson(annotation_file)
def is_crashed(self, track):
if self.crashed:
return True
if Geo.find_intersections(
self.get_polyline(), track.right) or Geo.find_intersections(
self.get_polyline(), track.left) or Geo.find_intersections(
self.get_polyline(), track.start):
self.crashed = True
return True
return False
def parse(self):
"""
Parses XYZ file both in standard and short (without header) formats.
Can read parameters from comment lines in format '%s= %s'.
If .XYZ file contains several geoemtries, a graph can be plot
(for now, IRC mode turns on if 'e' and 'x' parameters are given
for each geometry; if other parameter instead of 'x' is given,
Scan mode is activated)
"""
# Open file
try:
FI = open(self.file)
log.debug('%s was opened for reading' % (self.file))
except:
log.error('Cannot open %s for reading' % (self.file))
return '', ''
#
# Read file
#
geom = Geometry.Geom()
is_FirstLine = True
for s in FI:
splitted = s.strip().split()
if len(splitted) > 3:
if is_FirstLine: # Short XYZ
log.debug('Short XYZ format (without headers) recognized')
is_FirstLine = False
# Read Coords
splitted[0] = ChemicalInfo.to_elN(splitted[0])
geom.coord.append('%s %s %s %s\n' % tuple(splitted[:4]))
# +Vectors
if len(splitted) == 7:
log.debug('Displacement vectors found')
self.vector.append('%s %s %s\n' % tuple(splitted[4:]))
#
elif len(splitted) == 1:
if is_FirstLine: # Standard XYZ
is_FirstLine = False
log.debug('Standard XYZ format recognized')
else:
self.geoms.append(geom)
# New Record
geom = Geometry.Geom()
try:
geom.header_natoms = int(splitted[0])
except:
log.warning('Cannot read number of atoms from the header')
try:
comment = next(FI).strip()
except:
log.warning('Unexpected EOF while reading comment line')
geom.parseComment(comment)
self.geoms.append(geom)
FI.close()
def regular_polygon_filter(contour_list,
side_amount=6,
min_angle_ratio=0.9,
min_area_ratio=0.85,
min_len_ratio=0.9,
approx_coef=0.02):
"""
Action: A filter that Detects regular polygon of n-sides sides
:param contour_list: the list of contours to be filtered
:param side_amount: the amount of sides the wanted polygon has.
:param min_angle_ratio: the minimum ratio between the each angle and the average angle and the average angle and the
target angle of a shape of side_amount
:param min_area_ratio: The minimum ratio between the contour's area and the target area
:param min_len_ratio: The minimum ratio between the length of each side and the average length and
between the average length.
:param approx_coef: the coefficient for the function cv2.approxPolyDP.
:return:
"""
if side_amount < 3:
return []
output = []
ratio_list = []
if type(contour_list) is not list:
contour_list = [contour_list]
for currentContour in contour_list:
vertices, lengths, angles = Geometry.get_lengths_and_angles(
currentContour, approx_coef)
if len(vertices) == side_amount:
target_angle = Geometry.n_polygon_angle(side_amount)
average_length = round(sum(lengths) / float(len(lengths)), 3)
average_angle = round(sum(angles) / float(len(lengths)), 3)
invalid_value = False
for length in lengths:
if 1 - (root((length - average_length)**2, 2) /
average_length) < min_len_ratio:
invalid_value = True
break
if not invalid_value:
for angle in angles:
if 1 - (root((angle - average_angle)**2, 2) /
average_angle) < min_angle_ratio:
invalid_value = True
break
if not invalid_value:
if 1 - (root((target_angle - average_angle)**2, 2) /
target_angle) < min_angle_ratio:
invalid_value = True
if not invalid_value:
ratio = cv2.contourArea(
currentContour) / Geometry.n_polygon_area(
average_length, side_amount)
if min_area_ratio <= ratio <= 1 / min_area_ratio:
ratio_list.append(ratio)
output.append(currentContour)
return output, ratio_list
def connect(self):
plate = self._Car__env.getPlate(self)
self._Car__rewardSocket.addReward(plate.assignReward(self))
self._Car__rewardSocket.sendReward()
if self._Car__stateSocket:
if not self.n_angles:
state = plate.id * self.fine_rot_sensor
orientation = (geom.angVec(self._Car__direction) +
int(360 / (2 * self.fine_rot_sensor))) % 360
state += int(orientation / (360 / self.fine_rot_sensor))
else:
dists = []
for i in range(self.n_angles):
min_t = None
deg = np.pi * 2 / self.n_angles * i + geom.angVec(
self._Car__direction) / 180 * np.pi
ang = {}
ang["cos"] = np.cos(deg)
ang["sin"] = np.sin(deg)
ang["tan"] = ang["sin"] / ang["cos"] if ang[
"cos"] != 0 else None
ang["cotan"] = ang["cos"] / ang["sin"] if ang[
"sin"] != 0 else None
for wall in self._Car__env.getWalls():
t = wall.getDistance(self._Car__position, ang)
min_t = t if (not min_t or
(t and t < min_t)) else min_t
dists.append(min_t)
state = 0
digit = 1
for dist in dists:
state += digit * int(
dist / self.l_pieces if dist /
self.l_pieces < self.n_pieces else self.n_pieces)
digit *= self.n_pieces + 1
orientation = geom.angVec(self._Car__direction)
# orientation = int(orientation/(360/self.fine_rot_sensor))
self._Car__stateSocket.setState(state)
self.__direction_socket.setState(int(orientation))
self.__move_socket.setState(plate.bestMove)
self._Car__stateSocket.sendState()
self.__direction_socket.sendState()
self.__move_socket.sendState()
self._Car__env.moveReward(plate.trail, self)
def has_two_pointer_fingers(hand): #Checks if we are using two pointer fingers
if len(hand.fingers) < 2: #Obviously not
return False
sorted_fingers = sort_fingers_by_distance_from_screen(hand.fingers)
finger1_pos = Geometry.to_vector(sorted_fingers[0].tip_position)
finger2_pos = Geometry.to_vector(sorted_fingers[1].tip_position)
difference = finger1_pos - finger2_pos
if difference.norm() < 40: #Check if the fingertips are close together
return True
else:
return False
def has_two_pointer_fingers(hand): #Checks if we are using two pointer fingers
if len(hand.fingers) < 2: #Obviously not
return False
sorted_fingers = sort_fingers_by_distance_from_screen(hand.fingers)
finger1_pos = Geometry.to_vector(sorted_fingers[0].tip_position)
finger2_pos = Geometry.to_vector(sorted_fingers[1].tip_position)
difference = finger1_pos - finger2_pos
if difference.norm() < 40: #Check if the fingertips are close together
return True
else:
return False
def test_moixx(self):
#Testing the moment of inertia calculations for floor contribution
#Values are compared to hand calculated values
x_bar, y_bar = Geometry.centroid(R, h_f, t_f, t_s, n_s, t_st, h_st,
w_st)
floor_Ixx, fuselage_Ixx, stringer_Ixx = Geometry.MOIxx(
x_bar, y_bar, stringer_area, R, h_f, t_f, t_s, n_s, t_st, h_st,
w_st, w_f)
assert round(floor_Ixx, 4) == round(0.0610583336, 4)
assert round(fuselage_Ixx, 4) == round(0.097228, 4)
assert round(stringer_Ixx, 4) == round(0.003182835606813844, 4)
def test_moiyy(self):
#Testing the moment of inertia calculations for floor contribution
#Values are compared to hand calculated values
x_bar, y_bar = Geometry.centroid(R, h_f, t_f, t_s, n_s, t_st, h_st,
w_st)
floor_Iyy, fuselage_Iyy, stringer_Iyy = Geometry.MOIyy(
x_bar, y_bar, stringer_area, R, h_f, t_f, t_s, n_s, t_st, h_st,
w_st, w_f)
assert round(floor_Iyy, 4) == round(0.354558415, 4)
assert round(fuselage_Iyy, 4) == round(0.052749892705925, 4)
assert round(stringer_Iyy, 4) == round(0.0030239999999999998, 4)
def test_polylines():
test_seg_1 = geo.Line('6,6', '9,9')
test_seg_2 = geo.Line('9,9', '10,10')
test_seg_3 = '6,3', '6,6'
test_poly = geo.Polyline()
test_poly.addSegment(test_seg_1)
test_poly.addSegment(test_seg_2)
test_poly.addSegment(test_seg_3)
desc = "Test of the Polyline Class."
expected = 5.65685
actual = test_poly.length()
print_test_results(test_polylines, desc, expected, actual)
def addConvex(self, convex, colour=None):
"""docstring for addConvex"""
if not Visualiser.VISUALISER_ON:
return
if isinstance(convex, geo.Convex):
if colour == None:
print "Color is none"
visual.convex(pos=polygon.pts, color=geo.norm([0.1,0.1,0.1]), material=visual.materials.plastic)
else:
import pdb; pdb.set_trace()
print "Colour is", geo.norm(colour)
visual.convex(pos=convex.points, color=geo.norm(colour), material=visual.materials.plastic)
def addFinitePlane(self, plane, colour=None, opacity=0.):
if not Visualiser.VISUALISER_ON:
return
if isinstance(plane, geo.FinitePlane):
if colour == None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length/2, plane.width/2, H/2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0,0,1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=0)
def addConvex(self, convex, colour=None, opacity=1., material=None):
"""docstring for addConvex"""
if not VISUAL_INSTALLED:
return
if isinstance(convex, geo.Convex):
if material is None:
material = visual.materials.plastic
if colour == None:
print "Color is none"
visual.convex(pos=convex.points, color=geo.norm([0.1,0.1,0.1]), material=material)
else:
#import pdb; pdb.set_trace()
print "Colour is", geo.norm(colour)
visual.convex(pos=convex.points, color=geo.norm(colour), material=material)
def addFinitePlane(self, plane, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(plane, geo.FinitePlane):
if material is None:
material = visual.materials.plastic
if colour == None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length/2, plane.width/2, H/2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0,0,1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=opacity, material=material)
def has_thumb(hand): #The level of accuracy with this function is surprisingly high
if hand.fingers.empty: #We assume no thumbs
return False
distances = []
palm_position = Geometry.to_vector(hand.palm_position)
for finger in hand.fingers: #Make a list of all distances from the center of the palm
finger_position = Geometry.to_vector(finger.tip_position)
difference = finger_position - palm_position
distances.append(difference.norm()) #Record the distance from the palm to the fingertip
average = sum(distances)/len(distances)
minimum = min(distances)
if average - minimum > 20: #Check if the finger closest to the palm is more than 20mm closer than the average distance
return True
else:
return False
def addCylinder(self, cylinder, colour=None):
if not Visualiser.VISUALISER_ON:
return
if colour == None:
colour = visual.color.blue
#angle, direction, point = tf.rotation_from_matrix(cylinder.transform)
#axis = direction * cylinder.length
position = geo.transform_point([0,0,0], cylinder.transform)
axis = geo.transform_direction([0,0,1], cylinder.transform)
print cylinder.transform, "Cylinder:transform"
print position, "Cylinder:position"
print axis, "Cylinder:axis"
print colour, "Cylinder:colour"
print cylinder.radius, "Cylinder:radius"
visual.cylinder(pos=position, axis=axis, color=colour, radius=cylinder.radius, opacity=0.5, length = cylinder.length)
def getEdgeFromPoint(self, point, margin=8):
for node in self.nodes:
for edge in node._neighbors:
distance = Geom.distFromLineSeg(edge.line, point)
if distance <= margin:
return edge
return None
def evolve(self):
""" Run evolution.
"""
pop_size = 100
seeds = []
seed = []
for aa in self.sequence:
geo = Geometry.geometry(aa)
seed.append(geo.phi)
seed.append(geo.psi_im1)
template_seeds = self.create_seeds(self.path + "/pdbs2")
seeds += template_seeds
seeds += [seed for x in range(100 - len(template_seeds))]
self.es.terminator = terminators.evaluation_termination
self.es.evolve(generator=self.generator,
evaluator=self.eval_func,
pop_size=pop_size,
maximize=False,
max_evaluations=2000000000,
bounder=self.bounder,
seeds=seeds,
neighborhood_size=10,
cognitive_rate=1,
social_rate=1,
num_inputs=self.c_size)
def addLine(self, start, stop, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if colour == None:
colour = visual.color.white
axis = np.array(stop) - np.array(start)
visual.cylinder(pos=start, axis=axis, radius=0.0001, color=geo.norm(colour), opacity=opacity, material=material)
def on_AddNPolygonButton_clicked(self, widget):
N = int(Gtk.Entry.get_text(self.NSidesEntry))
Radius = float(Gtk.Entry.get_text(self.NRadiusEntry))
Center = tuple(map(int, Gtk.Entry.get_text(self.NCenterEntry).split(",")))
Angle = float(Gtk.Entry.get_text(self.NAngleEntry))
Polygon = Geometry.n_Sided_Polygon(N, Radius, Center, Angle)
self.Shapes.append(Polygon)
def addLine(self, start, stop, colour=None):
if not Visualiser.VISUALISER_ON:
return
if colour == None:
colour = visual.color.white
axis = np.array(stop) - np.array(start)
visual.cylinder(pos=start, axis=axis, radius=0.0001, color=geo.norm(colour))
def collides(self,p): #print Geometry.distance(self.x,self.y,p.x,p.y), self.r if Geometry.distance(self.x,self.y,p.x,p.y) < self.r: p.kill() return True else: return False
def build_all_angles_model(pdb_filename):
parser=PDBParser()
structure=parser.get_structure('sample', \
path.join(PDBdir, pdb_filename))
model=structure[0]
chain=model['A']
model_structure_geo=[]
prev="0"
N_prev="0"
CA_prev="0"
CO_prev="0"
prev_res=""
rad=180.0/math.pi
for res in chain:
if(res.get_resname() in resdict.keys()):
geo=Geometry.geometry(resdict[res.get_resname()])
if(prev=="0"):
N_prev=res['N']
CA_prev=res['CA']
C_prev=res['C']
prev="1"
else:
n1=N_prev.get_vector()
ca1=CA_prev.get_vector()
c1=C_prev.get_vector()
C_curr=res['C']
N_curr=res['N']
CA_curr=res['CA']
c=C_curr.get_vector()
n=N_curr.get_vector()
ca=CA_curr.get_vector()
geo.CA_C_N_angle=calc_angle(ca1, c1, n)*rad
geo.C_N_CA_angle=calc_angle(c1, n, ca)*rad
psi= calc_dihedral(n1, ca1, c1, n) ##goes to current res
omega= calc_dihedral(ca1, c1, n, ca) ##goes to current res
phi= calc_dihedral(c1, n, ca, c) ##goes to current res
geo.psi_im1=psi*rad
geo.omega=omega*rad
geo.phi=phi*rad
geo.N_CA_C_angle= calc_angle(n, ca, c)*rad
##geo.CA_C_O_angle= calc_angle(ca, c, o)*rad
##geo.N_CA_C_O= calc_dihedral(n, ca, c, o)*rad
N_prev=res['N']
CA_prev=res['CA']
C_prev=res['C']
##O_prev=res['O']
model_structure_geo.append(geo)
return model_structure_geo
def add_state(self):
new_state_name = self.control_window.state_entry.get()
print(new_state_name)
self.control_window.state_entry.delete(0, END)
self.states.append(State(self.control_window.frame, new_state_name))
new_state = self.states[-1]
new_state.state_label.grid(row=len(self.states), column=0)
new_state.transition_button.configure(text="TRANSITION", command=lambda : self.transition(new_state))
new_state.transition_button.grid(row=len(self.states), column=1)
new_state.delete_button.configure(text="DELETE", command=lambda : self.delete_state(new_state))
new_state.delete_button.grid(row=len(self.states), column=2)
new_state.accept_button.configure(text="ACCEPT", command=lambda : self.make_accepting(new_state))
new_state.accept_button.grid(row=len(self.states), column=3)
new_state.entry_button.configure(text="--->", command=lambda : self.make_entry(new_state))
new_state.entry_button.grid(row=len(self.states), column=4)
self.parser.add_state(new_state)
Geometry.add_state(self.canvas_window, new_state, self.states)
pass
def addRay(self, ray, colour=None):
if not Visualiser.VISUALISER_ON:
return
if isinstance(ray, geo.Ray):
if colour == None:
colour = visual.color.white
pos = ray.position
axis = ray.direction * 5
visual.cylinder(pos=pos, axis=axis, radius=0.0001, color=geo.norm(colour))
def build_Grid(self):
try:
for sph in self.dictSpheres.keys():
if float(1.0 / self.Spacer) - float(int(1.0 / self.Spacer)) > 0.001:
xmin = float(int((self.dictSpheres[sph][1][0] - self.dictSpheres[sph][0]) / self.Spacer)) * self.Spacer;
ymin = float(int((self.dictSpheres[sph][1][1] - self.dictSpheres[sph][0]) / self.Spacer)) * self.Spacer;
zmin = float(int((self.dictSpheres[sph][1][2] - self.dictSpheres[sph][0]) / self.Spacer)) * self.Spacer;
xmax = float(int((self.dictSpheres[sph][1][0] + self.dictSpheres[sph][0]) / self.Spacer) + 1.0) * self.Spacer;
ymax = float(int((self.dictSpheres[sph][1][1] + self.dictSpheres[sph][0]) / self.Spacer) + 1.0) * self.Spacer;
zmax = float(int((self.dictSpheres[sph][1][2] + self.dictSpheres[sph][0]) / self.Spacer) + 1.0) * self.Spacer;
else:
xmin = float(int(self.dictSpheres[sph][1][0] - self.dictSpheres[sph][0] - self.Spacer));
ymin = float(int(self.dictSpheres[sph][1][1] - self.dictSpheres[sph][0] - self.Spacer));
zmin = float(int(self.dictSpheres[sph][1][2] - self.dictSpheres[sph][0] - self.Spacer));
xmax = float(int(self.dictSpheres[sph][1][0] + self.dictSpheres[sph][0] + self.Spacer + 1.0))
ymax = float(int(self.dictSpheres[sph][1][1] + self.dictSpheres[sph][0] + self.Spacer + 1.0))
zmax = float(int(self.dictSpheres[sph][1][2] + self.dictSpheres[sph][0] + self.Spacer + 1.0))
x = xmin
y = ymin
z = zmin
sqrrad = sph.Radius
while z < zmax:
while y < ymax:
while x < xmax:
key = '%8.3f' % x
key += '%8.3f' % y
key += '%8.3f' % z
if key not in self.dictGridPoints:
sqrrad = self.dictSpheres[sph][0] * self.dictSpheres[sph][0]
if Geometry.sqrdistance( self.dictSpheres[sph][1], [ x, y, z ] ) < sqrrad:
self.dictGridPoints[key] = ''
x += self.Spacer
x = xmin
y += self.Spacer
x = xmin
y = ymin
z += self.Spacer
except:
return 1
return 0
def mouseMovement(self, x, y):
return Geometry.rotate2d((x, y), math.radians(self._mapRotation))
if self.current == Constants.N:
return (x, y)
elif self.current == Constants.NW:
return Geometry.rotate2d((x, y), math.radians(-45))
elif self.current == Constants.E:
return (-y, x)
elif self.current == Constants.NE:
return Geometry.rotate2d((-y, x), math.radians(-45))
elif self.current == Constants.S:
return (-x, -y)
elif self.current == Constants.SE:
return Geometry.rotate2d((-x, -y), math.radians(-45))
elif self.current == Constants.W:
return (y, -x)
else:
return Geometry.rotate2d((y, -x), math.radians(-45))
def addRay(self, ray, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(ray, geo.Ray):
if colour == None:
colour = visual.color.white
pos = ray.position
axis = ray.direction * 5
visual.cylinder(pos=pos, axis=axis, radius=0.0001, color=geo.norm(colour), opacity=opacity, material=material)
def addBox(self, box, colour=None):
if not Visualiser.VISUALISER_ON:
return
if isinstance(box, geo.Box):
if colour == None:
colour = visual.color.red
org = geo.transform_point(box.origin, box.transform)
ext = geo.transform_point(box.extent, box.transform)
print "Visualiser: box origin=%s, extent=%s" % (str(org), str(ext))
size = np.abs(ext - org)
pos = org + 0.5*size
print "Visualiser: box position=%s, size=%s" % (str(pos), str(size))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print "colour,", colour
if colour == [0,0,0]:
visual.box(pos=pos, size=size, opacity=0.3, material=visual.materials.plastic)
else:
visual.box(pos=pos, size=size, color=geo.norm(colour), opacity=0.5)
def draw(self, Canvas, line):
l_size = 8 / Canvas.Scale
point = self.pos
upPoint = (point[0], point[1]+ l_size)
downPoint = (point[0], point[1] - l_size)
rightPoint = (point[0] + l_size, point[1] - l_size)
lines = [upPoint, downPoint, rightPoint]
theta = Geom.angleFromXaxis(line)
lines = Geom.rotatePointList(lines, theta, point)
Canvas.AddLine(
[lines[0], lines[1]],
LineWidth=4,
LineColor="BLUE"
)
Canvas.AddLine(
[lines[1], lines[2]],
LineWidth=4,
LineColor="BLUE"
)
