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)
