def straight_straight(self, radio, dist1, dist2): """Return""" # Buscamos el centro del circulo recta11 = self.plant1.recta.parallel(dist1 + radio, self.izq1) recta22 = self.plant2.recta.parallel(dist2 + radio, self.izq2) pto_c = recta11.cutoff(recta22) recta_r1 = self.plant1.recta.parallel(dist1, self.izq1) recta_r2 = self.plant2.recta.parallel(dist2, self.izq2) pto_v = recta_r1.cutoff(recta_r2) # Punto de corte de la recta centro-vertice con el circulo pto_p = pto_c.project(radio, pto_c.azimuth(pto_v)) # Rectas perpendiculares de xc,yc y xp,yp al eje 1 azi_1 = recta11.azimuth() - self.izq1 * math.pi / 2 pto_t1 = pto_c.project(dist1 + radio, azi_1) recta_p1 = Base.Straight(pto_p, None, azi_1, 10) pto_p1 = self.plant1.recta.cutoff(recta_p1) # Rectas perpendiculares de xc,yc y xp,yp al eje 2 azi_2 = recta22.azimuth() - self.izq2 * math.pi / 2 pto_t2 = pto_c.project(dist2 + radio, azi_2) recta_p2 = Base.Straight(pto_p, None, azi_2, 10) pto_p2 = self.plant2.recta.cutoff(recta_p2) d_1 = self.plant1.pto_ini.distance(pto_t1) + self.plant1.pk_ini d_2 = self.plant1.pto_ini.distance(pto_p1) + self.plant1.pk_ini d_3 = self.plant2.pto_ini.distance(pto_t2) + self.plant2.pk_ini d_4 = self.plant2.pto_ini.distance(pto_p2) + self.plant2.pk_ini return [self._get_dif(d_1, d_2, radio), self._get_dif(d_3, d_4, radio)]
def straight_curve(self, radio, dist1, dist2): """ Return """ azi_ini = self._get_azi_inout2(self.plant1.azimut_ini) # Giro a la der azi_1 = self._check_azimuth(self.plant1.azimut_ini + math.pi / 2) recta1 = Base.Straight(self.plant2.center, None, azi_1, 10) pto_c2 = self.plant1.recta.cutoff(recta1) d_2 = self.plant2.center.distance(pto_c2) azi_center = pto_c2.azimuth(self.plant2.center) if azi_1 == azi_center: l_s = abs(radio + dist1 + d_2 * self.izq1) else: l_s = abs(radio + dist1 - d_2 * self.izq1) hip = self._get_radio_leng(self.plant2, radio, dist2) alpha = math.asin(l_s / hip) l_t1 = hip * math.cos(alpha) pto_t1 = pto_c2.project(l_t1, azi_ini) pto_c = self.plant2.center.project(hip, azi_ini - self.inout * alpha) azi_c1c = self.plant2.center.azimuth(pto_c) if self.rounda: pto_p = pto_c.project(radio, azi_c1c, -self.izq2) else: if self.plant2.param < 0: beta = -1 * self.izq1 * self.izq2 * \ self._get_alpha(azi_c1c, pto_t1.azimuth(pto_c)) else: beta = self.izq1 * self.izq2 * \ self._get_alpha(azi_c1c, pto_c.azimuth(pto_t1)) pto_p = pto_c.project(radio, pto_c.azimuth(pto_t1) + beta / 2) recta_p = Base.Straight(pto_p, None, azi_ini - self.inout * self.izq1 * math.pi / 2, 10) pto_t2 = self.plant1.recta.cutoff(recta_p) d_1 = self.plant1.pto_ini.distance(pto_t1) + self.plant1.pk_ini d_2 = self.plant1.pto_ini.distance(pto_t2) + self.plant1.pk_ini azi_c1p = self.plant2.center.azimuth(pto_p) alpha = self._get_alpha(azi_c1c, self.plant2.azimut_ini) pk1 = self.plant2.pk_ini + alpha * abs(self.plant2.param) alpha = self._get_alpha(azi_c1p, self.plant2.azimut_ini) pk2 = self.plant2.pk_ini + alpha * abs(self.plant2.param) write_objs([pto_c2, self.plant2.center, pto_c, pto_t1, pto_p, pto_t2], radio) return [self._get_dif(d_1, d_2, radio), self._get_dif(pk1, pk2, radio)]
def curve_curve(self, radio, dist1, dist2): """Return""" azi_c1c2 = self.plant1.center.azimuth(self.plant2.center) r_b = self._get_radio_leng(self.plant1, radio, dist1) r_a = self._get_radio_leng(self.plant2, radio, dist2) r_c = self.plant1.center.distance(self.plant2.center) ang_a = math.acos((r_b ** 2 + r_c ** 2 - r_a ** 2) / (2 * r_b * r_c)) # ang_b = math.acos((r_a ** 2 + r_c ** 2 - r_b ** 2) / (2 * r_a * r_c)) # ang_c = math.pi - ang_a - ang_b azi_c1c = self._get_azi_inout(self.plant1, azi_c1c2, ang_a) pto_c = self.plant1.center.project(r_b, azi_c1c) alpha = self._get_alpha(azi_c1c, self.plant1.azimut_ini) pk_1 = self.plant1.pk_ini + alpha * abs(self.plant1.param) azi_c2c = self.plant2.center.azimuth(pto_c) alpha = self._get_alpha(azi_c2c, self.plant2.azimut_ini) pk_2 = self.plant2.pk_ini + alpha * abs(self.plant2.param) # roundabout if self.rounda: pto_p = pto_c.project(radio, azi_c2c, self.izq2) else: if self.plant1.param * self.plant2.param > 0: beta = self._get_alpha(-self.izq1 * azi_c1c, -self.izq2 * azi_c2c) / 2 else: beta = -self._get_alpha(-self.izq1 * azi_c1c, self.izq2 * azi_c2c) / 2 if self.plant1.izq == "Izq": pto_p = pto_c.project( radio, azi_c1c - self.izq2 * self.izq1 * self.inout * beta ) else: pto_p = pto_c.project( radio, self._azi_neg(azi_c1c) - self.izq2 * self.izq1 * self.inout * beta, ) azi_c1p = self.plant1.center.azimuth(pto_p) azi_c2p = self.plant2.center.azimuth(pto_p) alpha = self._get_alpha(azi_c1p, self.plant1.azimut_ini) pk_11 = self.plant1.pk_ini + alpha * abs(self.plant1.param) alpha = self._get_alpha(azi_c2p, self.plant2.azimut_ini) pk_22 = self.plant2.pk_ini + alpha * abs(self.plant2.param) # recta_c2c = Base.Straight(self.plant2.center, pto_c) recta_c1c = Base.Straight(self.plant1.center, pto_c) write_objs([pto_c, pto_p, recta_c1c.get_line(), recta_c2c.get_line()], radio) return [self._get_dif(pk_1, pk_11, radio), self._get_dif(pk_2, pk_22, radio)]
def _init_table_to_plant(self): """ Return """ pnt_center = Base.RoadPoint(self.polygon[0]) pnt_1 = Base.RoadPoint(self.polygon[1]) recta_1 = Base.Straight(pnt_center, pnt_1) rectas = [] new_rows = [] for i, dat in enumerate(self.road_table): new_rows.append(dat) if dat['lr_'] != 0: new_rows.append({ 'radio': 0.0, 'a_in': 0.0, 'a_out': 0.0, 'dc_': dat['dc_'], 'lr_': dat['lr_'] }) for i, dat in enumerate(new_rows[:-1]): dat1 = new_rows[i] dat2 = new_rows[i + 1] if dat1['radio'] == 0 and dat2['radio'] == 0: continue elif dat1['radio'] == 0: pnt_center, pnt_1, recta_1 = \ self._staight_curve(pnt_center, pnt_1, dat1, dat2) if i == 1: self.list_aligns.insert(0, recta_1) self.straight_curve_lengs.insert(1, recta_1.length()) elif dat2['radio'] == 0: pnt_center, pnt_1, recta_1 = \ self._curve_straight(pnt_center, pnt_1, dat1, dat2) elif abs(dat1['radio']) > abs(dat2['radio']) and dat1['a_out'] < 0: pnt_center, pnt_1, recta_1 = \ self._curve_high_low(pnt_center, pnt_1, dat1, dat2) elif abs(dat1['radio']) > abs(dat2['radio']) and dat2['a_in'] < 0: pnt_center, pnt_1, recta_1 = \ self._curve_low_high(pnt_center, pnt_1, dat1, dat2) else: raise ValueError('Error') rectas.append(recta_1) new_polygon = [rectas[0].pstart] for i, recta in enumerate(rectas[:-1]): if round(recta.azimuth(), 8) == round(rectas[i + 1].azimuth(), 8): continue new_polygon.append(recta.cutoff(rectas[i + 1])) new_polygon.append(rectas[-1].pend) self.polygon = Line(new_polygon) self.road_table.polyline = new_polygon
def _distx(self, rad, pc_d, pstart): """Return""" recta_pnt = pstart.normal(math.pi / 2) recta_c = Base.Straight(pc_d, None, pstart.azi, 10) pto_corte = recta_pnt.cutoff(recta_c) distxx = pc_d.distance(pto_corte) seno = math.sqrt(rad ** 2 - distxx ** 2) distx = pstart.distance(pto_corte) - seno return distx
def _init_poly_to_plant(self): """ Return """ dat1 = [] dat2 = [] line = self.polygon leng_accum = 0 for i, dat3 in enumerate(self.road_table): if i >= 2: if i == 2: end_pnt = line[0] recta1 = Base.Straight(end_pnt, line[i - 1]) recta2 = Base.Straight(line[i - 1], line[i]) alig = PlantAlign(dat2, dat1, dat3, recta1, recta2) leng_accum = alig.set_lengs_accum(leng_accum) self.list_aligns.extend(alig.get_aligns()) end_pnt = alig.get_endpnt() self.straight_curve_lengs.append(alig.straight.length()) self.straight_curve_lengs.append(alig.curve.length()) self.superelev_lim.append(alig.get_super_lim(self.bombeo)) dat1 = dat2 dat2 = dat3 if i == len(self.road_table) - 1: if len(self.road_table) == 2: end_pnt = line[i - 1] recta1 = Base.Straight(end_pnt, line[-1]) recta1.leng_accum = leng_accum self.list_aligns.append(recta1) self.straight_curve_lengs.append(recta1.length())
def _curve_high_low(self, pnt_center, pnt_1, dat1, dat2): """ Return """ # R1>R2 # Calculamos los puntos de tangencia de la clotoide con los dos circulo out_local = Base.cloth_local(dat1['radio'], dat1['a_out']) in_local = Base.cloth_local(dat2['radio'], dat2['a_in']) azi_in = pnt_center.azimuth(pnt_1) alpha = dat2['dc_'] / dat2['radio'] if dat1['radio'] > 0 and dat2['radio'] > 0: g90 = math.pi / 2 elif dat1['radio'] < 0 and dat2['radio'] < 0: g90 = -math.pi / 2 else: raise ValueError( "Error: For change the radio sing a straight must be \ between the radios") # return [None, None, None] pnt_t1 = pnt_center.project(abs(dat1['radio'] + out_local['y_o']), azi_in - out_local['tau']) pnt_t2 = pnt_t1.project(in_local['x_o'] - out_local['x_o'], azi_in - out_local['tau'] + g90) pnt_ad2 = pnt_t1.project(out_local['x_o'], azi_in - out_local['tau'] + g90) pnt_c2 = pnt_t2.project(abs(dat2['radio'] + in_local['y_o']), azi_in - out_local['tau'] + 2 * g90) pnt_ar2 = pnt_c2.project( abs(dat2['radio'], azi_in - out_local['tau'] + in_local['tau'])) pnt_ra2 = pnt_c2.project( abs(dat2['radio']), azi_in - out_local['tau'] + in_local['tau'] + alpha) if dat2['a_in'] != 0: cloth = Base.Clothoid(dat2['a_in'], dat2['radio'], pnt_ad2.azimuth(pnt_t2), 'in', None, pnt_c2) self.list_aligns.append() self.straight_curve_lengs.append(cloth.length()) curve = Base.Curve(dat2['radio'], alpha, pnt_c2.azimuth(pnt_ar2), pnt_c2) self.list_aligns.append(curve) self.straight_curve_lengs.append(curve.length()) return pnt_c2, pnt_ra2, Base.Straight(pnt_ad2, pnt_t1)
def _curve_low_high(self, pnt_center, pnt_1, dat1, dat2): """Return""" # R1<R2 out_local = Base.cloth_local(dat1["radio"], dat1["a_out"]) in_local = Base.cloth_local(dat2["radio"], dat2["a_in"]) azi_in = pnt_center.azimuth(pnt_1) alpha = dat2["dc_"] / dat2["radio"] if dat1["radio"] > 0 and dat2["radio"] > 0: g90 = math.pi / 2 elif dat1["radio"] < 0 and dat2["radio"] < 0: g90 = -math.pi / 2 else: raise ValueError("Error: For change the radio sing a straight \ must be between the radios") # return (None, None, None) pnt_t1 = pnt_center.project(abs(dat1["radio"] + out_local["y_o"]), azi_in + out_local["tau"]) pnt_t2 = pnt_t1.project(in_local["x_o"] - out_local["x_o"], azi_in + out_local["tau"] + g90) pnt_da1 = pnt_t1.project(out_local["x_o"], azi_in + out_local["tau"] + g90) pnt_c2 = pnt_t2.project(abs(dat2["radio"] + in_local["y_o"]), azi_in + out_local["tau"] + 2 * g90) pnt_ra2 = pnt_c2.project( abs(dat2["radio"]), azi_in + out_local["tau"] - in_local["tau"] + alpha) if dat1["a_out"] != 0: cloth = Base.Clothoid( dat1["a_out"], dat1["radio"], pnt_t1.azimuth(pnt_da1), "out", None, pnt_c2, ) self.list_aligns.append(cloth) self.straight_curve_lengs.append(cloth.length()) curve = Base.Curve(dat2["radio"], alpha, pnt_c2.azimuth(pnt_ra2), pnt_c2) self.list_aligns.append(curve) self.straight_curve_lengs.append(curve.length()) return pnt_c2, pnt_ra2, Base.Straight(pnt_t1, pnt_da1)
def _curve_straight(self, pnt_center, pnt_1, dat1, dat2): """ Return """ # R1 != 0 y R2 = 0 out_local = Base.cloth_local(dat1['radio'], dat1['a_out']) azi_in = pnt_center.azimuth(pnt_1) # pnt_ra = pnt_1 if dat1['radio'] > 0: g90 = math.pi / 2 else: g90 = -math.pi / 2 pnt_t1 = pnt_center.project(abs(dat1['radio'] + out_local['y_o']), azi_in + out_local['tau']) pnt_da = pnt_t1.project(out_local['x_o'], azi_in + out_local['tau'] + g90) azi_out = pnt_center.azimuth(pnt_t1) + g90 if dat1['a_out'] == 0: # pnt_da = pnt_ra pnt_da = pnt_1 else: cloth = Base.Clothoid(dat1['a_out'], dat1['radio'], azi_out, 'out', None, pnt_center) self.list_aligns.append(cloth) self.straight_curve_lengs.append(cloth.length()) pnt_out = pnt_da.project(dat2['lr_'], azi_in + out_local['tau'] + g90) recta = Base.Straight(pnt_da, pnt_out) self.list_aligns.append(recta) self.straight_curve_lengs.append(recta.length()) return pnt_da, pnt_out, Base.Straight(pnt_da, pnt_out)
def _polyg_parall(self, dist): """Return""" # line = self.polygon.read(1) self.polygon.open("r") line = self.polygon.cat(1, "lines", 1)[0] self.polygon.close() pnts = [] for i in range(len(line) - 1): straight = Base.Straight(line[i], line[i + 1]) pnts.append(straight.parallel(dist, self._intbool())) parallel = Line([pnts[0].pstart]) for i in range(len(pnts) - 1): parallel.append(pnts[i].cutoff(pnts[i + 1])) parallel.append(pnts[-1].pend) return parallel
def _init_align(self): """ Return """ local2_in = False local2_out = False if self.radio != 0: self.in_local = Base.cloth_local(self.radio, self.a_in) self.out_local = Base.cloth_local(self.radio, self.a_out) alpha = self._alpha() else: alpha = 0 p_center = self._center() if self.dat1['a_out'] < 0 and self.radio != 0: local2_out = Base.cloth_local(self.dat1['radio'], self.dat1['a_out']) self.cloth_in = Base.Clothoid(self.a_in, self.radio, self.recta1.azimuth(), 'in', local2_out, p_center) self.recta1.pend = self.cloth_in.pnt_d if self.dat1['a_out'] < 0 and self.radio != 0: self.recta1.pstart = self.cloth_in.pnt_p if self.radio == 0: az_ini = self.recta1.azimuth() else: az_ini = Base.azimut(p_center, self.cloth_in.pnt_r) self.curve = Base.Curve(self.radio, alpha, az_ini, p_center) if self.dat2['a_in'] < 0: local2_in = Base.cloth_local(self.dat2['radio'], self.dat2['a_in']) self.cloth_out = Base.Clothoid(self.a_out, self.radio, self.recta2.azimuth(), 'out', local2_in, p_center) self.straight = Base.Straight(self.recta1.pstart, self.recta1.pend, None, None)
def _staight_curve(self, pnt_center, pnt_1, dat1, dat2): """ Return """ # R1 = 0 y R2 != 0 in_local = Base.cloth_local(dat2['radio'], dat2['a_in']) alpha = dat2['dc_'] / dat2['radio'] azi_in = pnt_center.azimuth(pnt_1) pnt_ad = pnt_center.project(dat1['lr_'], azi_in) pnt_t2 = pnt_ad.project(in_local['x_o'], azi_in) if dat2['radio'] > 0: g90 = math.pi / 2 else: g90 = -math.pi / 2 pnt_c2 = pnt_t2.project(abs(dat2['radio'] + in_local['y_o']), azi_in + g90) pnt_c2.npk = dat1['lr_'] az_in_c = azi_in + in_local['tau'] - g90 if az_in_c < 0: az_in_c += 2 * math.pi pnt_ra = pnt_c2.project(abs(dat2['radio']), az_in_c + alpha) pnt_ra.npk = dat1['lr_'] if dat2['a_in'] != 0: cloth = Base.Clothoid(dat2['a_in'], dat2['radio'], azi_in, 'in', None, pnt_c2) self.list_aligns.append(cloth) self.straight_curve_lengs.append(cloth.length()) curve = Base.Curve(dat2['radio'], abs(alpha), az_in_c, pnt_c2) self.list_aligns.append(curve) self.straight_curve_lengs.append(curve.length()) return pnt_c2, pnt_ra, Base.Straight(pnt_center, pnt_ad)
def _get_straight(self): """ Return """ p_left = self.r_pnt.parallel(self.dist_left, -math.pi / 2) p_right = self.r_pnt.parallel(self.dist_right, math.pi / 2) return Base.Straight(p_left, p_right)
def init_straight(self): """Return""" self.azimut_ini = self.pto_ini.azimuth(self.pto_fin) self.recta = Base.Straight(self.pto_ini, None, self.azimut_ini, 10)