def setDirection(self, hero, point):
tile = hero.getTile()
cones = []
for x in range(len(tile.points)):
if x == 6:
break
else:
cones.append((line.Line(tile.points[x], tile.getCenter()),
line.Line(tile.points[x + 1], tile.getCenter())))
for cone in range(len(cones)):
if cone == 0:
if cones[cone][0].isPointGreaterThan(
point) and cones[cone][1].isPointLessThan(point):
hero.setDirection(1)
if cone == 1:
if cones[cone][0].isPointGreaterThan(
point) and cones[cone][1].isPointGreaterThan(point):
hero.setDirection(2)
if cone == 2:
if cones[cone][0].isPointLessThan(
point) and cones[cone][1].isPointGreaterThan(point):
hero.setDirection(3)
if cone == 3:
if cones[cone][0].isPointLessThan(
point) and cones[cone][1].isPointGreaterThan(point):
hero.setDirection(4)
if cone == 4:
if cones[cone][0].isPointLessThan(
point) and cones[cone][1].isPointLessThan(point):
hero.setDirection(5)
if cone == 5:
if cones[cone][0].isPointGreaterThan(
point) and cones[cone][1].isPointLessThan(point):
hero.setDirection(6)
def findWalls(cloud, startAngle, endAngle):
wStart, wEnd = startAngle, endAngle
walls = []
while wEnd < 360:
start, end = probableWall(cloud, wStart, wEnd, 15, 95) # look for wall
if start: # found a wall..
XY = splitXY(cloud, start, end)
m, b = leastSquare(XY) # calculate gradient/intersection of wall
farAway = 10000000
pt1 = (-farAway, (-farAway * m) + b)
pt2 = (farAway, farAway * m + b)
longLine = line.Line(pt1, pt2) # long line best fit to data
pt1, pt2 = bounds(XY)
if m < 0.0: # gradient is reversed # gradient of line between corners of the bound rectangle is always positive
myPt1 = longLine.closestPoint(pt2[0], pt1[1])
myPt2 = longLine.closestPoint(pt1[0], pt2[1])
else:
myPt1 = longLine.closestPoint(pt1[0], pt1[1])
myPt2 = longLine.closestPoint(pt2[0], pt2[1])
myLine = line.Line(myPt1, myPt2)
walls.append(myLine)
wStart = start
wEnd = end
wStart = wEnd
wStart = wStart + (wEnd - wStart) / 2
wEnd = wStart + 5
return walls
def testCoverAreaNumericalIntegration(self):
"""
Test the excess area computation.
"""
p1 = [20, 30]
p2 = [50, 60]
line_segment = Line(p1, p2)
lines = [line_segment]
ccle = circle.Circle(center=[40, 40], radius=15)
b, l, c = ccle.collides(line_segment)
self.assertTrue(b)
self.assertTrue(len(l) == 2)
self.assertTrue(c is not None)
l1 = line.Line(ccle.get_center(), c.get_p1())
l2 = line.Line(ccle.get_center(), c.get_p2())
angle = math.pi - l1.angle(l2)
# The angle that is outside the wedge.
remaining_angle = 2 * math.pi - angle
# The portion of the circle that is outside the wedge
portion_outside = remaining_angle / (2 * math.pi) * ccle.area()
# The triangle area
triangleArea = areaOfTriangle(c, l1, l2)
# The following is the exact computation of the excess area.
segmentArea = ccle.area() - (triangleArea + portion_outside)
# Now compare it with the numerical integration result.
segmentArea1, totalarea = circlecover.compute_excess_area([ccle],
lines)
print "segmentArea ", segmentArea, " segmentArea1 ", segmentArea1
self.assertTrue(np.allclose(segmentArea, segmentArea1, rtol=.01))
self.assertTrue(np.allclose(ccle.area(), totalarea, rtol=.01))
def __init__(self, viewport, gw, gh, paint):
Object.__init__(self, viewport)
utils.copy_object(paint, self)
# draw
num_lines = int(viewport.w / gw) - 1
x = viewport.x + gw
for l in range(0, num_lines):
v = line.Line()
v.x1 = x
v.y1 = viewport.y
v.x2 = x
v.y2 = v.y1 + viewport.h
x += gw
self.append(v)
num_lines = int(viewport.h / gh) - 1
y = viewport.y + gh
for l in range(0, num_lines):
h = line.Line()
h.x1 = viewport.x
h.y1 = y
h.x2 = h.x1 + viewport.w
h.y2 = y
y += gh
self.append(h)
def UP(self, node):
"""Repairs what DOWN did."""
while node != None:
#print "hola"
if node.__class__ == self.Line_Node:
node = node.parent
elif node.right == None:
node.local_env = node.left.local_env
node.bridge_left = None
node.bridge_right = None
node.left.local_env = None
node = node.parent
else:
(lleft, lright) = Envelope_Mantainer.point_of_intersection(
node.left.local_env, node.right.local_env)
(Env_left, n,
node.left.local_env) = node.left.local_env.split(lleft.key)
Env_left.insert_node(n)
(node.right.local_env, n,
Env_right) = node.right.local_env.split(lright.key)
Env_right.insert_node(n)
node.local_env = Env_left.join(Env_right)
if self.lower:
nlleft = line.Line()
nlleft.m = lleft.obj.m
nlleft.b = -lleft.obj.b
nlright = line.Line()
nlright.m = lright.obj.m
nlright.b = -lright.obj.b
else:
nlleft = lleft.obj
nlright = lright.obj
node.bridge_left = nlleft
node.bridge_right = nlright
node = node.parent
def tests():
pt0 = (0, 0)
pt1 = (0, 1)
pt2 = (1, 1)
pt3 = (1, 0)
pt4 = (0, 2)
pt5 = (2, 2)
pt6 = (2, 0)
l0 = line.Line(pt0, pt3)
l1 = line.Line(pt1, pt2)
l2 = line.Line(pt4, pt5)
l3 = line.Line(pt0, pt2)
t0 = Trap(l1, l0, pt0, pt3)
t1 = Trap(l2, l0, pt0, pt5)
t2 = Trap(l0, l1, pt3, pt0)
t3 = Trap(l3, l0, pt0, pt3)
# Check comparators
assert t0 != t1
assert t0 == t2
assert len(t0.corners) == 4
assert len(t3.corners) == 3
def TestSimpleLines():
print("###################################################")
l1 = line.Line([0, 2], 10)
l2 = line.Line([0, 16], 80)
orientation, intersect = l1.GetIntersection(l2)
PrintResult_Task7(orientation, intersect)
l1 = line.Line([0, 2], 10)
l2 = line.Line([0, 15], 80)
orientation, intersect = l1.GetIntersection(l2)
PrintResult_Task7(orientation, intersect)
l1 = line.Line([2, 0], 10)
l2 = line.Line([16, 0], 80)
orientation, intersect = l1.GetIntersection(l2)
PrintResult_Task7(orientation, intersect)
l1 = line.Line([2, 0], 10)
l2 = line.Line([15, 0], 80)
orientation, intersect = l1.GetIntersection(l2)
PrintResult_Task7(orientation, intersect)
l1 = line.Line([2, 0], 10)
l2 = line.Line([0, 16], 80)
orientation, intersect = l1.GetIntersection(l2)
PrintResult_Task7(orientation, intersect)
def __init__(self,ul,lr):
p = point.Point
self.rect = [
line.Line(ul,p(lr.x,ul.y)),
line.Line(p(lr.x,ul.y),p(lr.x,lr.y)),
line.Line(p(lr.x,lr.y),p(ul.x,lr.y)),
line.Line(p(ul.x,lr.y),p(ul.x,ul.y)), ]
def main():
rect = [
line.Line(point.Point(1, 6), point.Point(6, 6)),
line.Line(point.Point(5, 6), point.Point(5, 1)),
line.Line(point.Point(6, 1), point.Point(1, 1)),
line.Line(point.Point(1, 1), point.Point(1, 6))
]
print(rect)
def crossesEdge(self, node1, node2):
newLine = line.Line(node1, node2)
for source, targets in self.edges.iteritems():
for target in targets:
altLine = line.Line(source, target)
collision = newLine.lineLineIntersect(altLine)
if collision == line.LINE_INTERSECT:
return True
return False
def __init__(self, scene, pos, owning_civ):
super().__init__(scene, pos, owning_civ)
self.set_sprite_sheet("assets/warpship.png", 13)
self.tethered_to, _ = get_nearest(
self.pos, self.scene.get_civ_planets(owning_civ))
self.line1 = line.Line(V2(0, 0), V2(0, 0), PICO_LIGHTGRAY)
self.line2 = line.Line(V2(0, 0), V2(0, 0), PICO_RED)
self.scene.game_group.add(self.line1)
self.scene.game_group.add(self.line2)
self.update_lines()
def __init__(self):
self.line_left = line.Line()
self.line_right = line.Line()
self.detected = False
self.iteration = 0
self.lane_widths = [] # save lane width for last 10 iteration
self.lane_width = None
self.algorithms = [
proc.gradient_color, proc.yellow_white, proc.gradient_saturation
]
self.current_option = 0
def set_line_cluster(self):
directions = [(-1, 0), (0, -1), (1, 0), (0, 1)]
cluster = [line.Line(col_seq.Solid(WHITE))]
i = self.width-1
for dx, dy in directions:
cluster.append(line.Line(col_seq.Flicker(BLUE, clear=False, finite=False), point=(dx*i, dy*i)))
cluster.reverse()
return cluster
def isValid(self, sen, ref, newVars=None):
'''
Given a sentence and a set of reference lines, check that this proof proves
that the sentence is deductively follows from the reference lines
@return - True iff the proof proves that given sentence
'''
# Check that this proof is valid, if it is not then we canot check anything
if self.verify() is not True:
return False
# put all of the reference sentences into a list
refLines = []
for r in ref:
try:
refLines.append(r())
except ReferenceError:
return False
premises = self.getPremises()
# Generalize the premises
genPrem = set([])
for prem in premises:
genPrem.add(prem.generalize())
# TODO: Use other symbols for subproof
if sen.op() == '|-':
# Add the subproof assumption to the reference list
if str(sen.args()[0]) != '':
assumption = line.Line(self)
assumption.setSentence(sen.args()[0])
refLines.append(assumption)
# We are trying to prove the second part
sen = sen.args()[1]
## If we have variables that we need to be new
#if newVars is not None:
#for s in refSenList:
#for var in newVars:
## Check each sentence to see if it contains the "new" variable
#if var in s:
#return False
prevSens = []
metaSen = None
for s in self:
# Assume s is the conclusion
curSen = s.getSentence().generalize()
# Check if the current sentence can map into the conclusion
for conclusionMap in curSen.mapInto(sen):
# Try to map the assumptions to the refSenList
mapping = self.makeMapping(conclusionMap, genPrem, refLines)
if len(mapping) > 0:
# If there is a mapping then we are done
return True
return False
def __init__(self, obj=line.Line(), lower=False):
Treap.Node.__init__(self, key=obj.m)
#$Q_alpha$ in the "Mantainance of Configurations"
self.local_env = Envelope_Mantainer.Treap_Line(lower=lower)
#self.local_env.insert(obj)
self.bridge_left = obj
self.bridge_right = None
def check_entry(index_name, max_notify_count):
csv = rikka_const.entry_csv
df = pd.read_csv(csv, index_col=0)
temp_df = df[df.index == index_name]
stop_long_value = temp_df["stop_long"][0]
stop_short_value = temp_df["stop_short"][0]
notify_count = temp_df["notify_count"][0]
close_time, close_price = get_closeprice(index_name)
if close_price is None:
return
line_agent = line.Line(line_token.line_token)
if notify_count >= max_notify_count:
logger.debug(f"notify_count:[{notify_count}], max_notify_count:[{max_notify_count}]")
return
if stop_long_value != 0 and stop_long_value <= close_price:
notify_count += 1
msg = f"long trigger[{notify_count}]:" \
f"index[{index_name}],stop_long_value[{stop_long_value:.2f}], close_price[{close_price:.2f}]"
logger.info(msg)
line_agent.send_message(msg)
df.loc[index_name, "notify_count"] = notify_count
df.to_csv(csv)
elif stop_short_value != 0 and stop_short_value <= close_price:
notify_count += 1
msg = f"short trigger[{notify_count}]:index[{index_name}]" \
f", stop_short_value[{stop_short_value:.2f}], close_price[{close_price:.2f}]"
logger.info(msg)
line_agent.send_message(msg)
df.loc[index_name, "notify_count"] = notify_count
df.to_csv(csv)
else:
logger.debug(f"None Order index[{index_name}], close_price:[{close_price}]"
f", stop_long_value:[{stop_long_value}], stop_short_value:[{stop_short_value}]")
def insert(self, l):
obj = l
if self.lower:
obj = line.Line()
obj.m = l.m
obj.b = -l.b
Treap.insert(self, key=obj.m, obj=obj)
def confirm_line(self):
a = float(self.s.get())
b = float(self.s2.get())
self.top.destroy()
self._nb_lines += 1
l = line.Line(a, b, self.canv, self._nb_lines)
self.LINES.append(l)
def test_my_line(self):
# Add code here.
my_line = line.Line(1.1, 1.2, 1.3, 1.4)
self.assertAlmostEqual(my_line.x1, 1.1)
self.assertAlmostEqual(my_line.y1, 1.2)
self.assertAlmostEqual(my_line.x2, 1.3)
self.assertAlmostEqual(my_line.y2, 1.4)
def __init__(self, obj=line.Line(), lower=False):
Treap.Node.__init__(self, key=obj.m)
self.local_env = Envelope_Mantainer.Treap_Line(lower=lower)
self.local_env.insert(obj)
self.lines = [obj]
self.obj = obj
self.empty = False
def removeBadEdges(self):
# self.drawAll()
newEdges = dict()
for node, neighbors in self.edges.iteritems():
newEdges[node] = set()
for neighbor in neighbors:
edge = line.Line(node, neighbor)
edgeRect = edge.getBounds()
edgeRect.left -= self.minDistanceEdgeToNode
edgeRect.top -= self.minDistanceEdgeToNode
edgeRect.width += 2 * self.minDistanceEdgeToNode
edgeRect.height += 2 * self.minDistanceEdgeToNode
isSafeEdge = True
# No edges connecting different regions of the map.
if node.terrain != neighbor.terrain:
isSafeEdge = False
# No non-axis-aligned edges in axis-aligned parts of the map.
elif (game.map.getRegionInfo(node.terrain, 'aligned')
and game.map.getRegionInfo(neighbor.terrain, 'aligned')
and abs(node.x - neighbor.x) > constants.EPSILON
and abs(node.y - neighbor.y) > constants.EPSILON):
isSafeEdge = False
else:
for vecWrap in self.nodeTree.getObjectsIntersectingRect(
edgeRect):
nearNode = vecWrap.vector
if (nearNode not in [node, neighbor]
and edge.pointDistance(nearNode) <
self.minDistanceEdgeToNode):
isSafeEdge = False
break
if isSafeEdge:
newEdges[node].add(neighbor)
self.edges = self.addFixedEdges(newEdges)
def __init__(self,player,coords,wall):
#######################################################################################
# Programmer Name: Alec
# Date: 5/15/17
# Purpose: initializes attributes of a block
# Input: self, player, coords, wall
# Output: attributes of the object
#######################################################################################
self.x=coords[0] # top left coordinate
self.y=coords[1]
length=Block.LENGTH # localized length of each side
self.c=(self.x+length//2,self.y+length//2)
# create each side in the side list
self.sides=[line.Line([self.x+length,self.y],[self.x,self.y],wall), # north
line.Line([self.x,self.y+length],[self.x+length,self.y+length],wall), # south
line.Line([self.x,self.y],[self.x,self.y+length],wall), # west
line.Line([self.x+length,self.y+length],[self.x+length,self.y],wall)] # east
def splitLineString(lineString):
res = []
coords = lineString.coords
p0 = coords[0]
for k in range(1, len(lineString.coords)):
p1 = coords[k]
res.append(line.Line(p0, p1))
p0 = p1
return res
def __init__(self):
group.Group.__init__(self)
l = line.Line()
l.x1 = 0
l.y1 = -3
l.x2 = 0
l.y2 = 3
self.append(l)
def _merge_lines(cls, line_1, line_2):
"""Receives 2 mergeable lines, line_1.tail <= line_2.tail:
[Line, Line]
Returns the sum of the 2 lines:
Line
"""
new_tail = min(line_1.tail, line_2.tail)
new_head = max(line_1.head, line_2.head)
new_line = line.Line(new_tail, new_head)
return new_line
def testCoverAreaNumericalIntegration2(self):
p1 = [99.0, 29.0]
p2 = [100.0, 30.0]
line_segment = line.Line(p1, p2)
ccle = circle.Circle(center=[60, 20], radius=41.231)
self.assertTrue(ccle.inside(p1) and ccle.inside(p2))
segmentArea, totalArea = circlecover.compute_excess_area(
[ccle], [line_segment], grid_divisions=200)
print "segmentArea ", segmentArea
self.assertTrue(segmentArea != 0)
def get_line(self, line_pos, image_height):
l = line.Line()
l.allx, l.ally = zip(*line_pos)
l.current_fit = np.polyfit(l.ally, l.allx, 2)
ploty = np.linspace(0, image_height - 1, image_height)
l.fitx = l.current_fit[0] * ploty**2 + l.current_fit[
1] * ploty + l.current_fit[2]
l.curverad = self.calculate_curvature(l, ploty)
l.theta = self.theta(l.fitx)
return l
def __init__(self, text=None, part2=False):
# 1. Set the initial values
self.part2 = part2
self.text = text
self.lines = []
# 2. Process text (if any)
if text is not None and len(text) > 0:
for text_line in self.text:
self.lines.append(line.Line(text=text_line, part2=part2))
def find_lines(im, line_left=line.Line(), line_right=line.Line(), window_num=9):
# 车道线图像的shape
shape = im.shape
# 扫描窗口的高度
window_height = shape[0] / window_num
# 计算图像下1/4部分的直方图（降低运算规模，并减少噪声干扰，因为一般情况噪声出现在图像的靠上部分）
histogram = np.sum(im[int(shape[0] / 4 * 3):, :], axis=0)
if line_left.detected:
'''如果上一帧检测到了车道线'''
pass
else:
'''如果上一帧未检测到车道线'''
# 以直方图中最大值的x点为左边窗口检测起点
start_left_X = np.argmax(histogram[:int(shape[1] / 2)])
start_right_X = np.argmax(histogram[int(shape[1] / 2):]) + int(shape[1] / 2)
def linesIntersectionResolution(self, startLineName, destLineName):
# print "funcLinesIntersectionResolution(sl: %s, dl: %s)" % (startLineName, destLineName)
destLineIntersectionTaktNumber = 0 # start line enters dest line in this takt of dest line
destLineEndTakt = 0
startLineEndTakt = 0
linesDict = ln.Line().lines()
lineInfo = linesDict.get(startLineName, None)
if lineInfo == None:
print "funcLinesIntersectionResolution error"
return None
startLineEndTakt = lineInfo[1][1]
lineInfo = linesDict.get(destLineName, None)
if lineInfo == None:
print "funcLinesIntersectionResolution error"
return None
# if the dest line is the res line, then we assign the res takt to the destLineEndTakt
# otherwise the last takt of dest line will be assigned to destLineEndTakt
if self.resolutionLine == destLineName:
destLineEndTakt = self.resolutionTakt
else:
destLineEndTakt = lineInfo[1][1]
parallelLinesIntersectionDict = ln.Line().parallelLines()
destLineInx = lineInfo[0]
intersectionLines = parallelLinesIntersectionDict.get(startLineName, [])
for line in intersectionLines:
# line[0] = line index
# line[1] = intersection takt
if line[0] == destLineInx:
destLineIntersectionTaktNumber = line[1]
# if the start line is either Det line or Occ line, then return calculated
# info for start line and dest line
# otherwise, return the info for dest line
if self.occurranceLine == startLineName:
return [[self.occurranceTakt, startLineEndTakt], [destLineIntersectionTaktNumber, destLineEndTakt]]
elif self.occurranceLine == None and self.detectionLine == startLineName:
return [[self.detectionTakt, startLineEndTakt], [destLineIntersectionTaktNumber, destLineEndTakt]]
else:
return [[destLineIntersectionTaktNumber, destLineEndTakt]]
return None
