def path_of_white_ball(p1, p2, r):
pathBallW[:] = []
middle_ray = Line(p1, p2)
cue_circle = Circle(p1, r)
normal_line = middle_ray.perpendicular_line(p1)
points = intersection(cue_circle, normal_line)
pathBallW.append(middle_ray.parallel_line(points[0]))
pathBallW.append(middle_ray)
pathBallW.append(middle_ray.parallel_line(points[1]))
def calc_prompt_perpendicular_line(p_1: QPointF, p_2: QPointF,
p_mouse: QPointF):
if p_1 == p_2:
return None, None
mouse = Point(p_mouse.x(), p_mouse.y())
p_1 = Point(p_1.x(), p_1.y())
p_2 = Point(p_2.x(), p_2.y())
line = Line(p_1, p_2)
para_line = line.parallel_line(mouse)
perp_line_1 = line.perpendicular_line(p_1)
perp_line_2 = line.perpendicular_line(p_2)
conj_p1 = para_line.intersection(perp_line_1)
conj_p2 = para_line.intersection(perp_line_2)
qp1 = QPointF(conj_p1[0].x, conj_p1[0].y)
qp2 = QPointF(conj_p2[0].x, conj_p2[0].y)
return qp1, qp2
def calc_baseline(p1: QPointF, p2: QPointF, p_mouse: QPointF):
if p1 == p2:
return p1, p2
p1_s = Point(p1.x(), p1.y())
p2_s = Point(p2.x(), p2.y())
p_m = Point(p_mouse.x(), p_mouse.y())
line = Line(p1_s, p2_s)
if line.contains(p_m):
return p1, p2
perpendicular_1 = line.perpendicular_line(p1_s)
perpendicular_2 = line.perpendicular_line(p2_s)
para = line.parallel_line(p_m)
prompt_p_1 = para.intersection(perpendicular_1)
prompt_p_2 = para.intersection(perpendicular_2)
q_p_1 = QPointF(prompt_p_1[0].x, prompt_p_1[0].y)
q_p_2 = QPointF(prompt_p_2[0].x, prompt_p_2[0].y)
return q_p_1, q_p_2
plotpolygon(ax, obstacles[i])
width = np.append(width, 2.4)
cindex = 0
count = 0
convexcells = list(cells)
for cell in cells:
cutpt = []
if not (cell.is_convex()):
for vertice in cell.vertices:
if (cell.angles[vertice] > math.pi):
cutpt.append(vertice)
pts = pointtoarray(cutpt)
pts = pts[pts[:, 0].argsort()]
for pt in pts:
cut = yaxis.parallel_line(Point(pt))
cross = convexcells[cindex + count].intersection(cut)
if (len(cross) == 2):
cell1, cell2 = splitpolygon(convexcells[cindex + count], cut)
convexcells.remove(convexcells[cindex + count])
convexcells.insert(cindex + count, cell2)
convexcells.insert(cindex + count, cell1)
width = np.insert(width, cindex + count, width[cindex + count])
plotpolygon(ax, cell1)
count = count + 1
elif (len(cross) == 3):
seg1 = Segment(cross[0], cross[1])
cell1, cell2 = splitpolygon(convexcells[cindex + count], seg1)
convexcells.remove(convexcells[cindex + count])
convexcells.insert(cindex + count, cell2)
convexcells.insert(cindex + count, cell1)
starttime = time.time()
xaxis = Line((0, 0), (1, 0))
yaxis = Line((0, 0), (0, 1))
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_aspect('equal', 'box')
allinnerpt = np.array(allinnerpt)
allpt = allinnerpt[:]
num = len(boundary.vertices)
#find all critical points and decompose the area
criticalpoints = []
remain = boundary
bounds = remain.bounds
leftbound = bounds[0]
rightbound = bounds[2]
cut = yaxis.parallel_line(Point(leftbound, 0))
cross = boundary.intersection(cut)
if (isinstance(cross[0], Point)):
criticalpoints.append(cross[0])
else:
criticalpoints.append(cross[0].midpoint)
for i in range(num):
pt = boundary.vertices[i]
cut = yaxis.parallel_line(pt)
cross = boundary.intersection(cut)
crosspt = []
for item in cross:
if (isinstance(item, Point)):
crosspt.append(item)
else:
i = 0
ymax = (-a * bounding_box[0][1] - c) / b
ymin = (-a * bounding_box[0][0] - c) / b
scatter.add_scatter(x=[bounding_box[0][0], bounding_box[0][1]],
y=[ymin, ymax],
mode="lines",
hoveron="points")
scatter.show()
# %% padding
print(ymax)
perp_line = classif_line.perpendicular_line(classif_line.p1)
p1 = np.array([float(perp_line.p1[0]), float(perp_line.p1[1])])
p2 = np.array([float(perp_line.p2[0]), float(perp_line.p2[1])])
v = p1 - p2
u = v / np.linalg.norm(v, ord=1)
next_point = p1 + 2 * u
parallel_line1 = classif_line.parallel_line(classif_line.p1 + Point(0, 0.2))
a1, b1, c1 = parallel_line1.coefficients
ymax1 = float((-a1 * bounding_box[0][1] - c1) / b1)
ymin1 = float((-a1 * bounding_box[0][0] - c1) / b1)
scatter.add_scatter(x=[bounding_box[0][0], bounding_box[0][1]],
y=[ymin1, ymax1],
mode="lines",
hoveron="points")
parallel_line2 = classif_line.parallel_line(classif_line.p1 + Point(0, -0.2))
a2, b2, c2 = parallel_line2.coefficients
ymax2 = float((-a2 * bounding_box[0][1] - c2) / b2)
ymin2 = float((-a2 * bounding_box[0][0] - c2) / b2)
scatter.add_scatter(x=[bounding_box[0][0], bounding_box[0][1]],
y=[ymin2, ymax2],
mode="lines",
hoveron="points")
if (rightupindex < leftupindex):
uppoints = list(vertices[rightupindex:leftupindex + 1])
else:
uppoints = list(vertices[rightupindex:len(vertices)])
uppoints.extend(vertices[0:leftupindex + 1])
if (leftdownindex < rightdownindex):
downpoints = list(vertices[leftdownindex:rightdownindex + 1])
else:
downpoints = list(vertices[leftdownindex:len(vertices)])
downpoints.extend(vertices[0:leftupindex + 1])
index = findbound(uppoints)
buttomindex = index[1] #upper min y
if (index[1] == index[3]): #upper part is segment
up1 = None
else:
cut = xaxis.parallel_line(uppoints[buttomindex])
up1, temp = splitpolygon(polygon, cut)
index = findbound(downpoints)
topindex = index[3] #lower max y
if (index[1] == index[3]): #lower part is segment
down1 = None
else:
cut = xaxis.parallel_line(downpoints[topindex])
temp, down1 = splitpolygon(polygon, cut)
waypoint = []
if (up1 and down1):
waypoint = createwaypoint(up1, down1, pointpos[i])
elif (up1): #lower part is segment
upbound = up1.bounds
upmin = upbound[1] #ymin
upmax = upbound[3] #ymax
copiedcell=[]
for f in var:
if (var[f].X!=0):
if(f[0]=='x'):
copiedcell.append(f[1])
#update ane matrix
copiedcell.sort()
copiedcell.reverse()
newane=ane
for c in copiedcell:
newane=np.insert(newane,c,ane[:,c],axis=1)
copiedcell.reverse()
criticalpoints=[]
for pos in criticalpos:
cutpt=[]
cut=yaxis.parallel_line(Point(pos,0))
cross=boundary.intersection(cut)
if (len(cross)==1):
if(isinstance(cross[0],Point)):
criticalpoints.append(cross[0])
continue
else:
criticalpoints.append(cross[0].midpoint)
continue
for obstacle in obstacles:
cross=obstacle.intersection(cut)
if not(len(cross)==0):
if(isinstance(cross[0],Point)):
cutpt.append(cross[0])
else:
cutpt.append(cross[0].midpoint)
