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