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 formperpenicularlines(xpos):
xpos = xpos.reshape(len(cutpos), 1)
xpts = np.insert(xpos, 1, [0], axis=1)
xpts = map(Point, xpts)
xaxis = Line((0, 0), (1, 0))
cutlines = []
for pt in xpts:
cutline = xaxis.perpendicular_line(pt)
cutlines.append(cutline)
return cutlines
def get_osculating_center(pt, tang, radius, jnc_cntr):
init_line = Line(pt, pt + tang)
tang_perp = init_line.perpendicular_line(pt).direction.unit
cand_cntr1 = pt + tang_perp * radius
cand_cntr2 = pt - tang_perp * radius
dist_cand1 = jnc_cntr.distance(cand_cntr1)
dist_cand2 = jnc_cntr.distance(cand_cntr2)
if (dist_cand1 < dist_cand2):
res_cntr = cand_cntr1
else:
res_cntr = cand_cntr2
return res_cntr
def calculateFaceTilt(faceEyesIrisPoints, regionOfInterestColorObjects):
zeroLine = Line (Point (1,0), Point (0,0));
leftEye = Point (faceEyesIrisPoints.pop());
rightEye = Point (faceEyesIrisPoints.pop());
eyeMiddlePoint = Point ((leftEye + rightEye)/2);
eyeLine = Line (leftEye, rightEye);
faceSymmetryLine = eyeLine.perpendicular_line(eyeMiddlePoint);
angle = mpmath.degrees(eyeLine.angle_between(zeroLine));
if (int(angle) > 90):
return {'angle':int(angle) - 180, 'tiltline':faceSymmetryLine};
else:
return {'angle':int(angle), 'tiltline':faceSymmetryLine};
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 get_anchor_pt(p0, p1, t0, t1, r0, r1):
jnc_cntr, jnc_radius = get_junction_circle(p0, p1, t0, t1)
if -1 == jnc_radius:
# Straight line - "infinite" circle
anchor_pt = (p0 + p1) / 2.
else:
aux_start = get_auxiliary_pt(p0, t0, r0, jnc_cntr, jnc_radius, p1)
aux_end = get_auxiliary_pt(p1, t1, r1, jnc_cntr, jnc_radius, p0)
aux_mid_pt = (aux_start + aux_end) / 2.
if aux_mid_pt.distance(jnc_cntr) < 0.0001:
# half a circle. Give the preference to p0
assert abs(aux_mid_pt.distance(aux_start) - jnc_radius) < 0.0001
diameter_line = Line(aux_start, aux_end)
bisec_radius_vec = diameter_line.perpendicular_line(
jnc_cntr).direction.unit
anch_pt_1 = jnc_cntr + bisec_radius_vec * jnc_radius
anch_pt_2 = jnc_cntr - bisec_radius_vec * jnc_radius
test_pt = p0 + t0
closest_cand = get_closest_pt(anch_pt_1, anch_pt_2, test_pt)
if closest_cand == anch_pt_2:
bisec_radius_vec = -bisec_radius_vec
else:
bisec_radius_vec = Line(jnc_cntr, aux_mid_pt).direction.unit
anchor_pt = jnc_cntr + bisec_radius_vec * jnc_radius
DEBUG = 'IN_DEBUG' in globals()
if DEBUG and IN_DEBUG:
crc = mpt.Circle(
[float(aux_start.x), float(aux_start.y)],
radius=float(0.1),
color="#D4AC0D",
fill=True)
plt.gca().add_patch(crc)
crc = mpt.Circle(
[float(aux_end.x), float(aux_end.y)],
radius=float(0.1),
color="#D4AC0D",
fill=True)
plt.gca().add_patch(crc)
crc = mpt.Circle(
[float(anchor_pt.x), float(anchor_pt.y)],
radius=float(0.1),
color="#85929E",
fill=True)
plt.gca().add_patch(crc)
return anchor_pt
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
def calculateFaceTilt(faceEyesIrisPoints, regionOfInterestColorObjects):
zeroLine = Line(Point(1, 0), Point(0, 0))
leftEye = Point(faceEyesIrisPoints.pop())
rightEye = Point(faceEyesIrisPoints.pop())
eyeMiddlePoint = Point((leftEye + rightEye) / 2)
eyeLine = Line(leftEye, rightEye)
faceSymmetryLine = eyeLine.perpendicular_line(eyeMiddlePoint)
angle = mpmath.degrees(eyeLine.angle_between(zeroLine))
if (int(angle) > 90):
return {
'angle': int(angle) - 180,
'tiltline': faceSymmetryLine
}
else:
return {
'angle': int(angle),
'tiltline': faceSymmetryLine
}
def get_secondary_biarc(pt, tng, anchor, is_left):
init_line = Line(pt, pt + tng)
tng_perp = init_line.perpendicular_line(pt)
pt_anchor_bisec = get_bisector(pt, anchor)
intr = tng_perp.intersection(pt_anchor_bisec)
if 0 == len(intr):
raise ValueError("No intersection for secondary biarc center")
if isinstance(intr[0], Line):
raise ValueError("Line for secondary biarc center")
circ_cntr = intr[0]
radius = pt.distance(circ_cntr)
DEBUG = 'IN_DEBUG' in globals()
if DEBUG and IN_DEBUG:
color = "#FFCCFF" if is_left else "#B266FF"
draw_line(tng_perp, color)
draw_line(pt_anchor_bisec, color)
if is_left:
res = CircArc(pt, anchor, circ_cntr)
else:
res = CircArc(anchor, pt, circ_cntr)
return res
centroid2 = Point(clf.centroids_[1])
# centroid3 = Point(clf.centroids_[2])
l12 = Line(centroid1, centroid2)
# l23 = Line(centroid2, centroid3)
# l31 = Line(centroid1, centroid3)
closest_opposite_point12 = find_closest_point([Point(x) for x in points1],
centroid2)
# closest_opposite_point13 = find_closest_point([Point(x) for x in points1], centroid3)
closest_opposite_point21 = find_closest_point([Point(x) for x in points2],
centroid1)
# closest_opposite_point23 = find_closest_point([Point(x) for x in points2], centroid3)
# closest_opposite_point31 = find_closest_point([Point(x) for x in points3], centroid1)
# closest_opposite_point32 = find_closest_point([Point(x) for x in points3], centroid2)
perpendicular12 = l12.perpendicular_line(closest_opposite_point12)
# perpendicular13 = l31.perpendicular_line(closest_opposite_point13)
perpendicular21 = l12.perpendicular_line(closest_opposite_point21)
# perpendicular23 = l23.perpendicular_line(closest_opposite_point23)
# perpendicular31 = l31.perpendicular_line(closest_opposite_point31)
# perpendicular32 = l23.perpendicular_line(closest_opposite_point32)
# %%
plt.figure(figsize=(7, 7))
plt.xlim(-2, 10)
plt.ylim(-4, 8)
plt.plot(points1[:, 0], points1[:, 1], 'o')
plt.plot(points2[:, 0], points2[:, 1], 'ro')
# plt.plot(points3[:, 0], points3[:, 1], 'go')
plt.plot(clf.centroids_[:, 0],
clf.centroids_[:, 1],
'o',
'''
allinnerpt = np.array(allinnerpt)
allinnerpt = allinnerpt[np.lexsort((allinnerpt[:, 1], allinnerpt[:, 0]))]
xaxis = Line((0, 0), (1, 0))
yaxis = Line((0, 0), (0, 1))
remain = boundary
cells = []
points = []
for pt in allinnerpt:
isleft = False
isright = False
if (containitem(pt[0], obsleft)):
isleft = True
if (containitem(pt[0], obsright)):
isright = True
cut = xaxis.perpendicular_line(Point(pt))
if (isright):
crosspoint = remain.intersection(cut)
if (isinstance(crosspoint[-1], Point)):
seg1 = Segment(crosspoint[0], crosspoint[1])
seg2 = Segment(crosspoint[1], crosspoint[2])
cell, remain = splitpolygon(remain, seg1)
addtomodel(cell, points)
cells.append(cell)
cell, remain = splitpolygon(remain, seg2)
addtomodel(cell, points)
cells.append(cell)
else:
if (len(crosspoint) == 1):
continue
else:
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
buttom = downpoints[topindex].y #y of lower part
if (upmax - upmin <= width / 2):
waypoint = [Point(pointpos[i], upmax - width / 2)]
else:
cutpt = Point(pointpos[i], upmax - width / 2)
cut = yaxis.perpendicular_line(cutpt)
crosspoint = polygon.intersection(cut)
if (crosspoint[0].x < crosspoint[1].x):
leftcross = crosspoint[0]
rightcross = crosspoint[1]
else:
leftcross = crosspoint[1]
rightcross = crosspoint[0]
if (leftcross.x <= pointpos[i]
and rightcross.x >= pointpos[i]):
waypoint = [Point(pointpos[i], upmax - width / 2)]
elif (leftcross.x > pointpos[i]):
waypoint = [leftcross]
else:
waypoint = [rightcross]
if (upmin - buttom > width):
def __init__(self, pt_lead, pt_support, tang_lead, tang_support,
radius_lead):
global IN_DEBUG
DEBUG = 'IN_DEBUG' in globals()
if DEBUG:
p0tan = mpt.Arrow(float(pt_lead.x),
float(pt_lead.y),
float(tang_lead.x),
float(tang_lead.y),
width=0.1,
fc="b",
ec='none')
p1tan = mpt.Arrow(float(pt_support.x),
float(pt_support.y),
float(tang_support.x),
float(tang_support.y),
width=0.1,
fc="#2E86C1",
ec='none')
plt.gca().add_patch(p0tan)
plt.gca().add_patch(p1tan)
lead_tang_line = Line(pt_lead, pt_lead + tang_lead, evaluate=False)
lead_radius_line = lead_tang_line.perpendicular_line(pt_lead)
support_tang_line = Line(pt_support,
pt_support + tang_support,
evaluate=False)
support_radius_line = support_tang_line.perpendicular_line(pt_support)
if DEBUG:
draw_line(lead_radius_line, "#40E0D0")
draw_line(support_radius_line, "#CCCCFF")
radii_inx_pt = lead_radius_line.intersection(support_radius_line)
if 0 == len(radii_inx_pt):
raise ValueError("Radii lines are parallel")
radii_inx_pt = Point(radii_inx_pt[0], evaluate=False)
lead_radius_vec = Line(pt_lead, radii_inx_pt,
evaluate=False).direction.unit
support_radius_vec = Line(pt_support, radii_inx_pt,
evaluate=False).direction.unit
lead_osc_center = pt_lead + radius_lead * lead_radius_vec
anchor_suport_pt = pt_support + radius_lead * support_radius_vec
if DEBUG:
draw_point(lead_osc_center, "#40E0D0")
draw_point(anchor_suport_pt, "#CCCCFF")
osc_center_anchor_bisec = get_bisector(lead_osc_center,
anchor_suport_pt)
if DEBUG:
draw_line(osc_center_anchor_bisec, "#F7DC6F")
intr = support_radius_line.intersection(osc_center_anchor_bisec)
if 0 == len(intr):
raise ValueError("No intersection for secondary biarc center")
support_cntr = intr[0]
support_radius = pt_support.distance(support_cntr)
junction_pt = get_circles_intersection(lead_osc_center,
radius_lead,
support_cntr,
support_radius,
c0color="#CAE873")[0]
if DEBUG:
draw_point(support_cntr, "#EC7063")
draw_point(junction_pt, "#9B59B6")
self.p0 = pt_lead
self.t0 = tang_lead
self.r0 = radius_lead
self.c0 = lead_osc_center
self.p1 = pt_support
self.t1 = tang_support
self.r1 = support_radius
self.c1 = support_cntr
self.j = junction_pt
downpoints = list(vertices[leftdownindex:len(vertices)])
downpoints.extend(vertices[0:leftupindex + 1])
upindex = findbound(uppoints)
downindex = findbound(downpoints)
upmin = uppoints[upindex[1]].y #ymin
upmax = uppoints[upindex[3]].y #ymax
downmin = downpoints[downindex[1]].y
downmax = downpoints[downindex[3]].y
if (upmax - downmin <= width):
waypoint.append(Point(pointpos[i], (upmax + downmin) / 2))
else:
if (upmax - upmin <= width / 2):
waypoint.append(Point(pointpos[i], upmax - width / 2))
else:
cutpt = Point(pointpos[i], upmax - width / 2)
cut = yaxis.perpendicular_line(cutpt)
crosspoint = polygon.intersection(cut)
if (crosspoint[0].x < crosspoint[1].x):
leftcross = crosspoint[0]
rightcross = crosspoint[1]
else:
leftcross = crosspoint[1]
rightcross = crosspoint[0]
if (leftcross.x <= pointpos[i]
and rightcross.x >= pointpos[i]):
waypoint.append(Point(pointpos[i], upmax - width / 2))
elif (leftcross.x > pointpos[i]):
waypoint.append(leftcross)
if (upmin - downmax <= width):
waypoint.append(
Point(pointpos[i], (upmin + downmax) / 2))
clf.centroids_[:, 1],
'o',
c="black",
markersize=20)
plt.show()
# %%
centroid1 = Point(clf.centroids_[0])
centroid2 = Point(clf.centroids_[1])
l = Line(centroid1, centroid2)
closest_opposite_point1 = find_closest_point([Point(x) for x in points1],
centroid2)
closest_opposite_point2 = find_closest_point([Point(x) for x in points2],
centroid1)
perpendicular1 = l.perpendicular_line(closest_opposite_point1)
perpendicular2 = l.perpendicular_line(closest_opposite_point2)
# perpendicular1_points = np.array((point_to_float(perpendicular1.p1), point_to_float(perpendicular1.p2)))
# perpendicular2_points = np.array((point_to_float(perpendicular2.p1), point_to_float(perpendicular2.p2)))
plt.figure(figsize=(7, 7))
plt.plot(points1[:, 0], points1[:, 1], 'o')
plt.plot(points2[:, 0], points2[:, 1], 'ro')
plt.plot(clf.centroids_[:, 0],
clf.centroids_[:, 1],
'o',
c="black",
markersize=20)
plt.plot(clf.centroids_[:, 0], clf.centroids_[:, 1], c="black")
hull = ConvexHull(points1)
def get_arc_seg(pt, tang, radius, jnc_cntr, jnc_radius, prev_start, prev_end):
init_line = Line(pt, pt + tang)
tang_perp = init_line.perpendicular_line(pt).direction.unit
aux_cntr1 = pt + tang_perp * radius
aux_cntr2 = pt - tang_perp * radius
aux_cntr = get_closest_pt(aux_cntr1, aux_cntr2, jnc_cntr)
intr = get_circles_intersection(aux_cntr, radius, jnc_cntr, jnc_radius)
DEBUG = 'IN_DEBUG' in globals()
if DEBUG and IN_DEBUG:
crc = mpt.Circle(
[float(aux_cntr.x), float(aux_cntr.y)],
radius=float(radius),
ec="#7DCEA0",
fill=False)
plt.gca().add_patch(crc)
crc = mpt.Circle(
[float(aux_cntr.x), float(aux_cntr.y)],
radius=float(0.05),
color="#7DCEA0",
fill=True)
plt.gca().add_patch(crc)
if isinstance(intr, Circle) or 0 == len(intr):
segm_min = segm_max = (pt, -1)
#raise ValueError("No intersection for secondary biarc center")
elif 1 == len(intr):
#min_prev, max_prev = order_arc_seg(prev_start, prev_end, jnc_cntr)
#intr_ang = get_angle(float(intr[0].x - jnc_cntr.x),
# float(intr[0].y - jnc_cntr.y)) * 180 / np.pi
np_inx = np.array([intr[0].x, intr[0].y])
np_pstart = np.array([prev_start.x, prev_start.y])
np_pend = np.array([prev_end.x, prev_end.y])
#if eeq(intr_ang, min_prev[1]) or eeq(intr_ang, max_prev[1]):
if vec_eeq(np_inx, np_pstart) or vec_eeq(np_inx, np_pend):
segm_min = (prev_start, -1)
segm_max = (prev_end, -1)
else:
segm_min = segm_max = (intr[0], -1)
elif 2 == len(intr):
min_intr, max_intr = order_arc_seg(intr[0], intr[1], jnc_cntr)
min_prev, max_prev = order_arc_seg(prev_start, prev_end, jnc_cntr)
if max_intr[1] < min_prev[1] or min_intr[1] > max_prev[1] \
or eeq(max_intr[1], min_prev[1]) or eeq(min_intr[1], max_prev[1]):
segm_min = (prev_start, -1)
segm_max = (prev_end, -1)
else:
segm_min = max([min_intr, min_prev], key=lambda x: x[1])
segm_max = min([max_intr, max_prev], key=lambda x: x[1])
DEBUG = 'IN_DEBUG' in globals()
if DEBUG and IN_DEBUG:
crc = mpt.Circle(
[float(intr[0].x), float(intr[0].y)],
radius=float(0.05),
color="#FFCC99",
fill=True)
plt.gca().add_patch(crc)
crc = mpt.Circle(
[float(intr[1].x), float(intr[1].y)],
radius=float(0.05),
color="#FFCC99",
fill=True)
plt.gca().add_patch(crc)
#plt.gca().add_patch(crc)
#plt.axis('equal')
#plt.xlim([-5, 20])
#plt.ylim([-15, 10])
#plt.show()
return segm_min[0], segm_max[0]
a, b = coeff[0]
c = intercept[0]
x = sympy.symbols('x')
y = sympy.symbols('y')
classif_line = Line(a.item() * x + b.item() * y + c.item())
bounding_box = np.stack([np.min(samples, 0), np.max(samples, 0)]).transpose()
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
