Para revisar los resultados de un solo punto, de todos los resultados anteriores, se realiza una gráfica que muestre los círculos de cada baliza con los radios de las distancias estimadas.
La gráfica permite observar los detalles de trilateración para ese punto en particular.
Los sectores en una baliza se incorporan en el algoritmo como la estimación de ubicación del punto usando las otras balizas.
Para un punto de ejemplo, dado que baliza 'gtwRECT' tiene sectores, se usan las otras balizas 'gtwFIEC' y 'gtwFCNM' para estimar la ubicación y el ángulo que permite aproximar el sector donde se ubicaría el punto.
Este sector se usa para aplicar la ecuación que corresponde al 'gtwFIEC'.
El desarrollo continua desde la sección anterior con solo intervalos y se incorpora el concepto.
Algoritmo Python
# Localización por trilateración# Ubicación de puntos en el mapa# Girni 2020-10-07 propuesta: edelros@espol.edu.ecimport numpy as np
import sympy as sym
import matplotlib.pyplot as plt
import pandas as pd
import json
import girni_lora_libreria as girni
# INGRESO# revisar parametros al inicio
modo = 'rx'
medida = 'rssi'# archivos de entrada
arch_medUbAtrib = 'rsmP06_'+medida+'UbicaUsarSector01.txt'
arch_ecuaciones = 'rsmP06_ecuacionSector01.json'# archivos de salida
arch_trilatera = 'rsmP07_'+medida+'trilateraSector01.txt'# Parametros de grafica
mostrargrp = ['FIEC'] #['FIEC','FCNM','RECT','CIRC']
mostrartip = ['punto']
mostrarfuera = [0,1] #[0,1]
tolera_error = 2 # decimales en error# Referencias
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# Parámetros de grafica
tipograf = '2D'# '2D','' sin grafica# PROCEDIMIENTO
baliza_key = list(baliza.keys())
baliza_val = list(baliza.values())
# leer datoswithopen(arch_ecuaciones) as json_file:
ecuacion = json.load(json_file)
tabla = pd.read_csv(arch_medUbAtrib, index_col='etiqueta')
tabla = pd.DataFrame(tabla)
# coordenadas de baliza
coordbaliza = {}
for cadabaliza in baliza:
cualbaliza = baliza[cadabaliza]
coordbaliza[cadabaliza] = [tabla['c_este'][cualbaliza]]
coordbaliza[cadabaliza].append(tabla['c_norte'][cualbaliza])
# inicializa ubicados,encontrados, intervalos fuera, errores# ubicados tiene [distancia, distancia+1s, distancia +2s,total]
ubicados = np.zeros(shape=(3,4),dtype=int)
tabla['interv_fuera'] = ''
tabla['encontrado'] = np.nan
tabla['ensector'] = ''# suma de errores
sumatrilat = np.zeros(shape=(2,4),dtype=float)
sumagps = np.zeros(shape=(2,4),dtype=float)
sumagpsdx = np.zeros(shape=(2,4),dtype=float)
sumagpsdy = np.zeros(shape=(2,4),dtype=float)
# distancias y errores a cada balizafor unabaliza in baliza_val:
donde = baliza_val.index(unabaliza)
cualbaliza = baliza_key[donde]
columna = medida+'_'+modo+'_'+cualbaliza
tabla['dist0_'+cualbaliza] = np.nan
tabla['dist1_'+cualbaliza] = np.nan
tabla['dist2_'+cualbaliza] = np.nan
# distancia estimada por puntofor cadapunto in tabla.index:
p_rssi = tabla[columna][cadapunto]
esgrupo = tabla['grupo'][cadapunto]
estipo = tabla['tipo'][cadapunto]
unsector = 's0'ifnot(np.isnan(p_rssi)):
ecuacion_rssi = ecuacion[unabaliza][unsector]
if (esgrupo in mostrargrp) and (estipo in mostrartip):
ubicados[2,donde] = ubicados[2,donde] + 1
dist = girni.dist_rssi(p_rssi,ecuacion_rssi)
[distancia,e_mean,e_1std,e_2std,interv_fuera] = dist
dist1 = distancia + e_1std
dist2 = distancia + e_2std
tabla.loc[cadapunto,'dist0_'+cualbaliza] = distancia
tabla.loc[cadapunto,'dist1_'+cualbaliza] = dist1
tabla.loc[cadapunto,'dist2_'+cualbaliza] = dist2
if interv_fuera>0:
iflen(tabla['interv_fuera'][cadapunto])==0:
separador=''else:
separador=','
tabla.loc[cadapunto,'interv_fuera'] = tabla['interv_fuera'][cadapunto]+separador+cualbaliza
procesados = np.max(ubicados[2,:])
# Revisa un sector_estimado
columnas = list(tabla.keys())
for cadapunto in tabla.index:
for cualbaliza in baliza:
sector_baliza = 'sector_'+cualbaliza
unsector = 0
if sector_baliza in columnas:
unsector = tabla['sector_'+cualbaliza][cadapunto]
if unsector!=0:
# evalua en sector
donde = baliza_key.index(cualbaliza)
otrasbalizas = baliza_key.copy()
otrasbalizas.pop(donde)
# coordenadas de baliza
coord_otrasbalizas = {}
for cadaotrabaliza in otrasbalizas:
cualotrabaliza = baliza[cadaotrabaliza]
coord_otrasbalizas[cadaotrabaliza] = [tabla['c_este'][cualotrabaliza]]
coord_otrasbalizas[cadaotrabaliza].append(tabla['c_norte'][cualotrabaliza])
# cada punto a i*std
punto = {}
sumabaricentro = np.nan
for i inrange(0,3,1):
punto[i] = {}
cuenta = 0
for cadaotrabaliza in otrasbalizas:
punto[i][cadaotrabaliza] = tabla['dist'+str(i)+'_'+cadaotrabaliza][cadapunto]
# si existe distanciaifnot(np.isnan(punto[i][cadaotrabaliza])):
cuenta = cuenta + 1
# Hay 3 mediciones a balizaif cuenta==2:
localiza = girni.trilatera(punto[i],
coord_otrasbalizas,
tolera = 10e-4)
baricentro = localiza['baricentro']
barerror = localiza['barerror']
poligono = localiza['poligono']
sumabaricentro = np.sum(baricentro)
ifnot(np.isnan(sumabaricentro)):
breakifnot(np.isnan(sumabaricentro)):
# coordenadas baliza para identificar ángulo
b_este = tabla['c_este'][baliza[cualbaliza]]
b_norte = tabla['c_norte'][baliza[cualbaliza]]
# coordenadas del punto entre otras balizas
p_este = baricentro[0]
p_norte = baricentro[1]
dx = p_este-b_este
dy = p_norte-b_norte
theta = np.arctan2(dy,dx)
if theta<0:
theta = theta + 2*np.pi
sectores = ecuacion[baliza[cualbaliza]]['sector_rad']
nsectores = len(sectores)
otrosector = ''for i inrange(0,nsectores-1,1):
a = sectores[i]
b = sectores[i+1]
if theta>=a and theta<b:
otrosector = i+1
if otrosector !='':
tabla.loc[cadapunto,'sector_'+cualbaliza] = otrosector
# recalcula distancia con sector
columna = medida+'_'+modo+'_'+cualbaliza
p_rssi = tabla[columna][cadapunto]
ecuacion_rssi = ecuacion[baliza[cualbaliza]]['s'+str(otrosector)]
dist = girni.dist_rssi(p_rssi,ecuacion_rssi)
[distancia,e_mean,e_1std,e_2std,interv_fuera] = dist
dist1 = distancia + e_1std
dist2 = distancia + e_2std
tabla.loc[cadapunto,'dist0_'+cualbaliza] = distancia
tabla.loc[cadapunto,'dist1_'+cualbaliza] = dist1
tabla.loc[cadapunto,'dist2_'+cualbaliza] = dist2
# trilateración. localiza cada punto# cada punto a i*stdfor i inrange(0,3,1):
tabla['trilat_este_'+str(i)] = np.nan
tabla['trilat_norte_'+str(i)] = np.nan
tabla['trilat_error_'+str(i)] = np.nan
tabla['ubicado_'+str(i)] = np.nan
tabla['trilat_gps_error_'+str(i)] = np.nan
tabla['trilat_gps_dx_'+str(i)] = np.nan
tabla['trilat_gps_dy_'+str(i)] = np.nan
# procesa cada puntofor cadapunto in tabla.index:
esgrupo = tabla['grupo'][cadapunto]
# coordenadas GPS del punto
c_este = tabla['c_este'][cadapunto]
c_norte = tabla['c_norte'][cadapunto]
if esgrupo in mostrargrp:
# cada punto a i*std
punto = {}
for i inrange(0,3,1):
punto[i] = {}
cuenta = 0
for unabaliza in baliza:
punto[i][unabaliza] = tabla['dist'+str(i)+'_'+unabaliza][cadapunto]
# si existe distanciaifnot(np.isnan(punto[i][unabaliza])):
cuenta = cuenta + 1
# Hay 3 mediciones a balizaif cuenta==3:
localiza = girni.trilatera(punto[i],
coordbaliza,
tolera = 10e-4)
baricentro = localiza['baricentro']
barerror = localiza['barerror']
poligono = localiza['poligono']
sumabaricentro = np.sum(baricentro)
# Hay coordenadas de baricentroifnot(np.isnan(sumabaricentro)):
tabla.loc[cadapunto,'trilat_este_'+str(i)] = baricentro[0]
tabla.loc[cadapunto,'trilat_norte_'+str(i)] = baricentro[1]
tabla.loc[cadapunto,'trilat_error_'+str(i)] = np.round(barerror,tolera_error)
# error trilatera hacia gps
dx = baricentro[0] - c_este
dy = baricentro[1] - c_norte
error_gps = np.sqrt(dx**2+dy**2)
tabla.loc[cadapunto,'trilat_gps_error_'+str(i)] = np.round(error_gps,tolera_error)
tabla.loc[cadapunto,'trilat_gps_dx_'+str(i)] = np.round(dx,tolera_error)
tabla.loc[cadapunto,'trilat_gps_dy_'+str(i)] = np.round(dy,tolera_error)
# cuenta error si encuentra primera vez
cond1 = np.isnan(tabla['encontrado'][cadapunto])
cond2 = len(tabla['interv_fuera'][cadapunto])>0
k = int(cond2) #intervalo extendidoif cond1:
tabla.loc[cadapunto,'encontrado'] = i
ubicados[k,i] = ubicados[k,i]+1
sumatrilat[k,i] = sumatrilat[k,i] + np.round(barerror,tolera_error)
sumagps[k,i] = sumagps[k,i] + np.round(error_gps,tolera_error)
sumagpsdx[k,i] = sumagpsdx[k,i] + np.round(np.abs(dx),tolera_error)
sumagpsdy[k,i] = sumagpsdy[k,i] + np.round(np.abs(dy),tolera_error)
# contabiliza errores de localizados
ubicasuma = np.zeros(2)
ubicasumporc = np.zeros(2)
ubicaporc = np.zeros(shape=(2,3))
for k inrange(0,2,1):
ubicados[k,3] = int(np.sum(ubicados[k,0:3]))
ubicasuma[k] = np.sum(ubicados[k,0:3])
ubicasumporc[k] = np.round(100*ubicasuma[k]/ubicados[k,3],1)
for i inrange(0,3,1):
ubicaporc[k,i] = np.round(100*ubicados[k,i]/ubicasuma[k],1)
if ubicados[k,i]>0:
sumatrilat[k,i] = np.round(sumatrilat[k,i]/ubicados[k,i],1)
sumagps[k,i] = np.round(sumagps[k,i]/ubicados[k,i],1)
sumagpsdx[k,i] = np.round(sumagpsdx[k,i]/ubicados[k,i],1)
sumagpsdy[k,i] = np.round(sumagpsdy[k,i]/ubicados[k,i],1)
# SALIDAprint('Errores localizacion')
import prettytable as ptt
print('Errores estimado: Cota-Trilatera-polígono y Trilatera_vs_GPS')
mostrar = ptt.PrettyTable(['punto','i*std','fuera','trilat',
'gps','gps_dx','gps_dy','sect_d1','sect_d2','sect_d3'])
for cadapunto in tabla.index:
# selecciona puntos a mostrar
encontrado = tabla['encontrado'][cadapunto]
esgrupo = tabla['grupo'][cadapunto]
interv_fuera = int(len(tabla['interv_fuera'][cadapunto])!=0)
cond1 = not(np.isnan(encontrado))
cond2 = esgrupo in mostrargrp
cond3 = interv_fuera in mostrarfuera
if cond1 and cond2 and cond3:
encontrado = int(encontrado)
mostrar.add_row([cadapunto,
str(int(tabla['encontrado'][cadapunto])),
tabla['interv_fuera'][cadapunto],
str(tabla['trilat_error_'+str(encontrado)][cadapunto]),
str(tabla['trilat_gps_error_'+str(encontrado)][cadapunto]),
str(tabla['trilat_gps_dx_'+str(encontrado)][cadapunto]),
str(tabla['trilat_gps_dy_'+str(encontrado)][cadapunto]),
tabla['sector_d1'][cadapunto],
tabla['sector_d2'][cadapunto],
tabla['sector_d3'][cadapunto]
])
print(mostrar)
print('puntos con medidas: ',procesados)
loc_alg = np.round(100*np.sum(ubicados[:,3])/procesados,1)
print('localizados con algoritmo: ', np.sum(ubicados[:,3]),
' , '+str(loc_alg)+'%' )
print('Errores Promedio:')
resumen = ptt.PrettyTable(['error+i*std','cant','%','trilat',
'gps','gps_dx','gps_dy'])
for k inrange(0,2,1):
if k == 0:
texto = 'dentro'if k == 1:
texto = 'fuera'
resumen.add_row(['interv_'+texto,ubicados[k,3],'',
'','','',''])
for i inrange(0,3,1):
resumen.add_row(['error_'+str(i),ubicados[k,i],
str(ubicaporc[k,i])+'%',
sumatrilat[k,i],sumagps[k,i],
sumagpsdx[k,i],sumagpsdy[k,i],
])
print(resumen)
# salida hacia archivo
tabla.to_csv(arch_trilatera)
# Grafica ubicados ------------# Referencias para gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
colorstd = ['lightblue', 'lightgreen','orange']
colorlin = ['lightblue', 'lightgreen','orange']
if tipograf == '2D':
figura,grafica = plt.subplots()
# balizasfor unabaliza in coordbaliza:
g_este = coordbaliza[unabaliza][0]
g_norte = coordbaliza[unabaliza][1]
grafica.scatter(g_este,g_norte,
color = 'red',
marker = 'D',
label = cadapunto)
grafica.annotate(unabaliza,
(g_este,g_norte))
# Puntosfor cadapunto in tabla.index:
g_este = tabla['c_este'][cadapunto]
g_norte = tabla['c_norte'][cadapunto]
# selecciona puntos a mostrar
encontrado = tabla['encontrado'][cadapunto]
esgrupo = tabla['grupo'][cadapunto]
interv_fuera = int(len(tabla['interv_fuera'][cadapunto])!=0)
cond1 = not(np.isnan(encontrado))
cond2 = esgrupo in mostrargrp
cond3 = interv_fuera in mostrarfuera
if cond1 and cond2 and cond3:
encontrado = int(encontrado)
p_este = tabla['trilat_este_'+str(encontrado)][cadapunto]
p_norte = tabla['trilat_norte_'+str(encontrado)][cadapunto]
grafica.scatter(p_este,p_norte,
color = colorstd[encontrado],
label = cadapunto)
grafica.plot([p_este,g_este],
[p_norte,g_norte],
color = colorstd[encontrado],
linestyle='dotted')
grafica.scatter(g_este,g_norte,
color = 'blue',
label = cadapunto)
grafica.annotate(cadapunto,(g_este,g_norte),
color='blue')
grafica.set_xlabel('UTM_este')
grafica.set_ylabel('UTM_norte')
grafica.grid()
grafica.set_title('Puntos Ubicados')
plt.show()
Al incorporar en los algoritmos el uso de sectores, se obtienen resultados con menores errores de localización, estimados por trilateración y respecto a las coordenadas del gps.
Se realiza un enfoque para el área de vegetación, 'FIEC', para comparar resultados
Se observa que se tienen casi todos los puntos del área de vegetación ubicados. 'FIEC130' no se incorpora a la lista, pues no dispone de valores de Rssi para 'gtwFCNM'.
El detalle de los errores de localización de cada punto son:
En el detalle se observa que solo para 'FIEC101' se usó un intervalo extendido de la ecuación hacia 'd2' que es 'gtwFIEC' estimando que es por encontrarse en los límites de la sección de vegetación.
Para la baliza de Rectorado, hacia el área de estudio se encuentra el edificio Biblioteca que es suficientemente grande para bloquear parcialmente la señal y genera un efecto "sombra".
Biblioteca ESPOL
En la vista superior del área de mediciones, a la derecha se ubica el rectorado en la cima del cerro, la Biblioteca en una parte intermedia, y el área de vegetacion FIEC se ubica en la parte baja del cerro hacia la izquierda de la imagen.
La "sombra" en la parte de vegetación se delimita en el sector formado por el ángulo formado entre las líneas de baliza y punto de referencia.
En la imagen se identifica como sector 's0' al círculo completo, como si no hubiese sectorización, para luego realizar cortes para el sector 's1' de la "sombra".
El sector 's1', del ejemplo, usa los puntos de referencia de inicio y fin en el sentido de las manecillas del reloj:
- 'FIEC112' usado como inicio, pues la línea entre Rectorado y el punto FIEC112 pasa por el borde del edificio de Biblioteca. - 'FCNM110' es usado punto final del sector al delimitar el área de vegetación bajo estudio entre FIEC y FCNM desde RECTorado.
En cada sector, se usan también intervalos por distancia desde la baliza descrita en la sección anterior.
El asunto con sectores se presenta principalmente con la baliza 'gtwRECT', siendo el caso referencia para el desarrollo del algoritmo. El sector añade una variable y nivel al diccionario de la ecuación.
baliza: ‘gtwRECT’ , Sector: 's0'
Para el primer sector 's0' sin "somlbra" del edificion biblioteca, también se aplica un subintervalo con frontera buscada desde los 300 m y determinada con las fórmulas en un radio de 359 m.
baliza: ‘gtwFIEC’ , Sector: 's1'
Para el siguiente sector 's1' se observa el efecto de "sombra" del edificio Biblioteca, se presenta una recuperación de señal al alejar de la baliza de RECTorado y el edificio Biblioteca.
En la gráfica, la baliza de RECTorado se encuentra a la izquierda, pues el eje distancia aumenta de valor hacia la derecha.
Parámetros de sector
La variable 'sector_ref' contiene los puntos de referencia para un nuevo sector 's1'. Si 'sector_ref' no contiene valores [] se asume que una formula aplica todo el círculo predeterminada como sector 's0'.
Los puntos de referencia se convierten a su equivalente en radianes usando las coordenadas utm este y norte, valores en radianes que pasan a formar parte de diccionario de ecuaciones como 'sector_rad' usados luego para evaluar la ecuación.
El caso de la baliza 'gtwFIEC' no tiene observaciones de "sombra" para el área de vegetación que sean de tamaño considerable, por lo que se mantiene solo la división por segmentos.
Los resultados no varían gtwFCNM, pues no se ha aplicado este concepto de "sombra" para estas balizas, tan solo la división por subintevalos causadas por cambios de entorno.
Los resultados del algoritmo para usar en localización :
El primer parámetro para seleccionar la ecuación es el sector, 's0' y 's1', que en caso que sea un solo círculo se identifica como 's0'.
Dentro de cada sector, se mantiene el concepto de intervalos de distancia o radio. Se mantiene el concepto de la sección anterior, donde 'r0' corresponde a la linealización de todos los puntos en el sector. Cuando exiten sub-intervalos se usa 'r1', 'r2', etc para cada intervalo.
El número de ecuaciones corresponde al número de balizas y sectores establecidos para el análisis.
Se realizan cambios menores a la función pares_usar() de la librería girni para incorporar el parámetro sector, que al ser vacío '' funciona como fué descrito en las secciones anteriores.
pares_usar(tabla,baliza, analiza,unabaliza, unsector ='', medida = 'rssi', modo = 'rx')
También se actualizaron los nombres de los archivos de entrada y salida para diferenciar de los resultados anteriores y disponer de los archivos para comparar con los resultados del método que solo usa intervalos.
Algoritmo en Python
# LoRa-Multipunto, Rssi vs distancia con mínimos cuadrados
# linealización Rssi vs log10(distancia)
# por Sectores e intervalos , Graficas '2D'
# Girni 2020-10-07 propuesta: edelros@espol.edu.ec
import numpy as np
import pandas as pd
import json
import matplotlib.pyplot as plt
import girni_lora_libreria as girni
# INGRESO
# archivos de entrada
modo = 'rx'
medida = 'rssi'
arch_medidaubica = 'rsmP06_'+medida+'Ubica01sector1.txt'
# archivos de salida
arch_ecuaciones = 'rsmP07_ecuacionSector01.json'
arch_medUbAtrib = 'rsmP07_'+medida+'UbicaUsarSector01.txt'
# Analizar por segmentos
analiza = {'gtwRECT':{'analizar' : 1,
'sector_ref' : ['FIEC112','FCNM110'],
's0':{'atipico_std' : 1,
'frontera' : [300],
'atipInterv_std': [2,2],
'p_amplia': 2,
'grp' : ['RECT','FIEC'],
'tip' : ['punto'],
'LOS' : [1] },
's1':{'atipico_std' : 1,
'frontera' : [],
'atipInterv_std': [2],
'p_amplia': 2,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0] }
},
'gtwFIEC':{'analizar' : 1,
'sector_ref' : [],
's0':{'atipico_std' : 1,
'frontera' : [190],
'atipInterv_std': [1,1],
'p_amplia': 4,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [0,1] }
},
'gtwFCNM':{'analizar' : 1,
'sector_ref' : [],
's0':{'atipico_std' : 1,
'frontera' : [235.0],
'atipInterv_std': [2,2],
'p_amplia': 4,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0] }
}
}
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# Parámetros de grafica
tipograf = '2D' # '2D','' sin grafica
escala = 'log' # 'normal','log'
escalabase = 10 # 10
casicero = 1e-4
precision = 2
intersectar = 1 # 0:Falso, 1: Verdadero
# PROCEDIMIENTO
# leer datos
tabla = pd.read_csv(arch_medidaubica, index_col='etiqueta')
tabla = pd.DataFrame(tabla)
baliza_key = list(baliza.keys())
baliza_val = list(baliza.values())
# Resultados de análisis
ecuacion = {}
eq_graf = {}
# analiza datos hacia una baliza
for unabaliza in analiza:
donde = baliza_val.index(unabaliza)
cualbaliza = baliza_key[donde]
# Parámetros
analizar = analiza[unabaliza]['analizar']
if analizar:
# Crea ecuacion por baliza
ecuacion[unabaliza] = {'sector_rad':[]}
eq_graf[unabaliza] = {}
# sectores
sectores = []
sector_ref = analiza[unabaliza]['sector_ref']
tabla['sector_'+cualbaliza] = 0 # 'todos' predeterminado
# coordenadas baliza para identificar ángulo
b_este = tabla['c_este'][unabaliza]
b_norte = tabla['c_norte'][unabaliza]
# sectores por puntos de referencia
if len(sector_ref)>0:
for cadapunto in sector_ref:
p_este = tabla['c_este'][cadapunto]
p_norte = tabla['c_norte'][cadapunto]
dx = p_este - b_este
dy = p_norte - b_norte
theta = np.arctan2(dy,dx)
if theta<0 and dx<0:
theta = theta + 2*np.pi
sectores.append(theta)
sectores = np.array(sectores)
ordenar = np.argsort(sectores)
sectores = list(sectores[ordenar])
nsectores = len(sectores)
# clasifica puntos por sector particular
for cadapunto in tabla.index:
dentrosector = 0
p_este = tabla['c_este'][cadapunto]
p_norte = tabla['c_norte'][cadapunto]
dx = p_este-b_este
dy = p_norte-b_norte
theta = np.arctan2(dy,dx)
if theta<0 and dx<0:
theta = theta + 2*np.pi
for j in range(0,nsectores-1,1):
if theta>sectores[j] and theta<sectores[j+1]:
dentrosector = j+1
tabla.loc[cadapunto,'sector_'+cualbaliza] = dentrosector
# ecuacion por baliza y sector
ecuacion[unabaliza]['sector_rad'] = sectores
nsectores = len(sectores)
if nsectores == 0:
nsectores = 1
for cadasector in range(0,nsectores,1):
unsector = 's'+str(cadasector)
ecuacion[unabaliza][unsector] = {}
eq_graf[unabaliza][unsector] = {}
# ecuación con todos los puntos como referencia
[pares,par_etiqueta] = girni.pares_usar(tabla,baliza,analiza,
unabaliza,unsector,
medida,modo)
xi = pares[:,0]
yi = pares[:,1]
n_xi = len(xi)
# coeficiente de correlación
correlacion = np.corrcoef(xi,yi)[0,1]
# minimos cuadrados
ecuacion0 = girni.linealiza_lstsq(xi,yi)
# selecciona atipicos de todos los puntos
atipico_std = analiza[unabaliza][unsector]['atipico_std']
alpha = ecuacion0['alpha']
beta = ecuacion0['beta']
fdist0 = lambda d: -10*alpha*(np.log10(d))+beta
yi0 = fdist0(xi)
dyi0std = ecuacion0['error_std']
dyi0 = yi - yi0
atipicos = np.abs(dyi0) >= dyi0std*atipico_std
xi0_e = xi[atipicos]
yi0_e = yi[atipicos]
etiq0_e = par_etiqueta[atipicos]
unintervalo = 'r0' # todos
# para exportar hacia archivo o gráfica
ecuacion[unabaliza][unsector] = {unintervalo: ecuacion0 }
ecuacion[unabaliza][unsector][unintervalo]['correlacion'] = correlacion
eq_graf[unabaliza][unsector] = {unintervalo: {'xi_graf' : xi,
'yi_graf' : yi,
'etiqueta' : par_etiqueta,
'linea' : yi0,
'atipicos' : [xi0_e,yi0_e],
'atip_etiq': etiq0_e}
}
# Intervalos radiales en sector
intervalo = [np.min(xi),np.max(xi)]
frontera = analiza[unabaliza][unsector]['frontera']
if len(frontera)>0:
# revisar si frontera esta dentro intervalo
frontera = np.array(frontera, dtype=float)
revisar = (frontera>=np.min(xi)) & (frontera<=np.max(xi))
enintervalo = list(frontera[revisar])
intervalo.extend(enintervalo)
intervalo = np.array(intervalo)
ordenar = np.argsort(intervalo)
intervalo = intervalo[ordenar]
n_intervalo = len(intervalo)
# analizar cada subintervalo
p_inicio = 0
p_desde = 0
p_amplia = analiza[unabaliza][unsector]['p_amplia']
atipIntv_std = analiza[unabaliza][unsector]['atipInterv_std']
for i in range(0,n_intervalo-1,1):
i_eq = 'r' + str(i+1)
# puntos en subintervalo [a,b]
a = intervalo[i]
b = intervalo[i+1]
subintervalo = (xi >= a) & (xi <= b)
xi_sub = xi[subintervalo]
yi_sub = yi[subintervalo]
n_sub = len(xi_sub)
etiq_sub = par_etiqueta[p_inicio:p_inicio + n_sub]
# amplia sub-intervalo, mejora intersecta rectas
detras = p_inicio
retrocede = detras
if detras > p_amplia:
retrocede = p_amplia
delante = n_xi - (p_inicio+n_sub)# -1)
avanza = delante
if delante >= p_amplia:
avanza = p_amplia
p_desde = p_inicio - retrocede
p_hasta = p_inicio + (n_sub) + avanza
p_inicio = p_inicio + (n_sub-1)
# subintervalo, amplia puntos
xi_a = xi[p_desde:p_hasta]
yi_a = yi[p_desde:p_hasta]
etiq_a = par_etiqueta[p_desde:p_hasta]
# coeficiente de correlación
correlacion1 = np.corrcoef(xi_a,yi_a)[0,1]
# analiza subintervalo
ecuacion1 = girni.linealiza_lstsq(xi_a,yi_a)
ecuacion[unabaliza][unsector][i_eq] = ecuacion1
ecuacion[unabaliza][unsector][i_eq]['correlacion'] = correlacion1
# atipicos del subintervalo extendido
alpha = ecuacion1['alpha']
beta = ecuacion1['beta']
fdist1 = lambda d: -10*alpha*(np.log10(d))+beta
yi1 = fdist1(xi_a)
dyi1std = ecuacion1['error_std']
atipicos = np.zeros(len(xi_a),dtype=bool)
atipico_std = analiza[unabaliza][unsector]['atipInterv_std'][i]
dyi1 = yi_a - yi1
if np.abs(dyi1std) > casicero:
atipicos = np.abs(dyi1) >= dyi1std*atipico_std
xi1_e = xi_a[atipicos]
yi1_e = yi_a[atipicos]
etiq1_e = etiq_a[atipicos]
# para gráfica, atipicos sin extender puntos
atipicos_sub = (xi1_e >= a) & (xi1_e<=b)
xi_sub1_e = xi1_e[atipicos_sub]
yi_sub1_e = yi1_e[atipicos_sub]
etiq_sub1e = etiq1_e[atipicos_sub]
eq_graf[unabaliza][unsector][i_eq] = {'atipicos': [xi_sub1_e,yi_sub1_e],
'atip_etiq':etiq_sub1e}
# subintervalo sin atipicos
if len(xi1_e)>0:
atipicoNo = np.abs(dyi1) <= dyi1std*atipico_std
xi2 = xi_a[atipicoNo]
yi2 = yi_a[atipicoNo]
etiq2 = etiq_a[atipicoNo]
# coeficiente de correlación
correlacion2 = np.corrcoef(xi2,yi2)[0,1]
ecuacion2 = girni.linealiza_lstsq(xi2,yi2)
# actualiza ecuación sin atipicos intervaloy
intervalox = ecuacion1['intervalox']
ecuacion2['intervalox'] = intervalox.copy()
alpha = ecuacion2['alpha']
beta = ecuacion2['beta']
fdist = lambda d: -10*alpha*(np.log10(d))+beta
intervaloy = fdist(intervalox)
ordenar = np.argsort(intervaloy)
intervaloy = list(intervaloy[ordenar])
ecuacion2['intervaloy'] = intervaloy
ecuacion[unabaliza][unsector][i_eq] = ecuacion2
ecuacion[unabaliza][unsector][i_eq]['correlacion'] = correlacion2
# Revisar frontera entre subintervalos,
# calcula intersección de rectas como nueva frontera
interv_calc = np.copy(intervalo)
if len(intervalo) >2 and intersectar==1 :
for i in range(0,n_intervalo-2,1):
ai = 'r' + str(i+1)
bi = 'r' + str(i+2)
ma = ecuacion[unabaliza][unsector][ai]['alpha']
ba = ecuacion[unabaliza][unsector][ai]['beta']
mb = ecuacion[unabaliza][unsector][bi]['alpha']
bb = ecuacion[unabaliza][unsector][bi]['beta']
# punto de intersección o cruce
cruzanx = 10**((bb-ba)/(10*(mb-ma)))
dfrontera = frontera - cruzanx
# cruce dentro de intervalo de ecuacion
if cruzanx > intervalo[-1]:
cruzanx = intervalo[-1]
if cruzanx < intervalo[0]:
cruzanx = intervalo[0]
interv_calc[i+1] = cruzanx
# para grafica evalua cada subintervalo sin atipicos
n_interv_calc = len(interv_calc)
for i in range(0,n_interv_calc-1,1):
i_eq = 'r'+str(i+1)
a = interv_calc[i]
b = interv_calc[i+1]
subintervalo = (xi >= a) & (xi <= b)
xi_sub = xi[subintervalo]
yi_sub = yi[subintervalo]
xi_graf = np.copy(xi[subintervalo])
if not(a in xi_graf):
xi_graf = np.concatenate(([a],xi_graf),axis=0)
if not(b in xi_graf):
xi_graf = np.concatenate((xi_graf,[b]),axis=0)
# Evalua subintervalo con la ecuacion sin atipicos
alpha = ecuacion[unabaliza][unsector][i_eq]['alpha']
beta = ecuacion[unabaliza][unsector][i_eq]['beta']
fdist = lambda d: -10*alpha*(np.log10(d))+beta
yi1_sub = fdist(xi_sub)
yi_graf = fdist(xi_graf)
eq_graf[unabaliza][unsector][i_eq]['xi_graf'] = xi_graf
eq_graf[unabaliza][unsector][i_eq]['yi_graf'] = yi_graf
a = np.round(np.min([xi_graf]),precision)
b = np.round(np.max([xi_graf]),precision)
ecuacion[unabaliza][unsector][i_eq]['intervalox'] = [a,b]
ay = np.round(np.min([yi_graf]),precision)
by = np.round(np.max([yi_graf]),precision)
ecuacion[unabaliza][unsector][i_eq]['intervaloy'] = [ay,by]
# SALIDA
for unabaliza in ecuacion:
for unsector in ecuacion[unabaliza]:
if unsector == 'sector_rad':
print('baliza: ',unabaliza)
print(' sectores radianes: ',ecuacion[unabaliza]['sector_rad'])
if unsector != 'sector_rad':
for i_eq in ecuacion[unabaliza][unsector]:
unintervalo = ecuacion[unabaliza][unsector][i_eq]['intervalox']
unintervaloy = ecuacion[unabaliza][unsector][i_eq]['intervaloy']
error_medio = ecuacion[unabaliza][unsector][i_eq]['error_medio']
error_std = ecuacion[unabaliza][unsector][i_eq]['error_std']
eq_latex = ecuacion[unabaliza][unsector][i_eq]['eq_latex']
errorx_medio = ecuacion[unabaliza][unsector][i_eq]['errorx_medio']
errorx_std = ecuacion[unabaliza][unsector][i_eq]['errorx_std']
correlacion = ecuacion[unabaliza][unsector][i_eq]['correlacion']
print(' [sector][intervalo]: ',unsector,',',i_eq)
print(' ' + eq_latex)
print(' ','intervalox: ',np.round(unintervalo,precision))
print(' ','intervaloy: ',np.round(unintervaloy,precision))
print(' correlación: ',np.round(correlacion,precision))
print(' |error_rssi| promedio: ',np.round(error_medio,precision),
' , std:',np.round(error_std,precision))
print(' |error_dist| promedio: ',np.round(errorx_medio,precision),
' , std:',np.round(errorx_std,precision))
print()
# salida hacia archivo
with open(arch_ecuaciones, 'w') as outfile:
json.dump(ecuacion, outfile)
tabla.to_csv(arch_medUbAtrib)
# GRAFICA
# Referencias para gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
if tipograf=='2D':
for unabaliza in ecuacion:
for unsector in ecuacion[unabaliza]:
if not(unsector=='sector_rad'):
figura,grafica = plt.subplots()
if escala == 'log':
grafica.set_xscale(escala,base=escalabase)
# todos los puntos
unintervalo = 'r0'
xi = eq_graf[unabaliza][unsector][unintervalo]['xi_graf']
yi = eq_graf[unabaliza][unsector][unintervalo]['yi_graf']
etiqueta = eq_graf[unabaliza][unsector][unintervalo]['etiqueta']
grafica.scatter(xi,yi,marker='.')
m = len(xi)
for i in range(0,m,1):
grafica.annotate(etiqueta[i],(xi[i],yi[i]))
# linealizado con todos los puntos
fdtxt = ecuacion[unabaliza][unsector][unintervalo]['eq_latex']
yi0 = eq_graf[unabaliza][unsector][unintervalo]['linea']
a = np.round(np.min([xi]),precision)
b = np.round(np.max([xi]),precision)
eq_texto = fdtxt +' ; ['+ str(a) +','+ str(b)+']'
grafica.plot(xi,yi0,label=eq_texto,linestyle='dotted')
# linealizado por subintervalo
eq_interv = list(ecuacion[unabaliza][unsector].keys())
eq_interv.pop(0)
n_intervalo = len(eq_interv)
for i_eq in eq_interv:
fdtxt = ecuacion[unabaliza][unsector][i_eq]['eq_latex']
grtxt = ecuacion[unabaliza][unsector][i_eq]['eqg_latex']
xi_graf = eq_graf[unabaliza][unsector][i_eq]['xi_graf']
yi_graf = eq_graf[unabaliza][unsector][i_eq]['yi_graf']
a = np.round(np.min([xi_graf]),precision)
b = np.round(np.max([xi_graf]),precision)
eq_texto = fdtxt+' ; ['+str(a)+','+str(b)+']'
grafica.plot(xi_graf,yi_graf, label=eq_texto)
# atipicos marcados en subintervalo
[xi1_e,yi1_e] = eq_graf[unabaliza][unsector][i_eq]['atipicos']
etiq1_e = eq_graf[unabaliza][unsector][i_eq]['atip_etiq']
grafica.scatter(xi1_e,yi1_e, color='red')
m = len(etiq1_e)
for i in range(0,m,1):
grafica.annotate(etiq1_e[i],
(xi1_e[i],yi1_e[i]),
color='red')
# lineas de frontera
grafica.axvline(a, color='lightblue')
valor_frontera = str(np.round(a,precision))
grafica.annotate(valor_frontera,
(a,np.max([yi,yi0])),
color='lightblue')
grafica.axvline(b, color='lightblue')
valor_frontera = str(np.round(b,precision))
grafica.annotate(valor_frontera,
(b,np.max([yi,yi0])),
color='lightblue')
# etiquetas y títulos
grafica.legend()
grafica.set_ylabel(medida+'_'+modo)
grafica.set_xlabel('distancia')
grafica.grid(True,linestyle='dotted',
axis='x', which='both')
untitulo = unabaliza+'_'+unsector+': '
untitulo = untitulo+medida+'_'+modo+' vs distancia'
grafica.set_title(untitulo)
plt.show()
Para el procesamiento de los datos se incorpora una función a girni_lora_libreria para realizar la linealización por mínimos cuadrados.
linealiza_lstsq(xi,yi,digitos = 3)
La función se encarga de convertir el eje x en log10(x), asi como construir las ecuaciones en la forma numérica lambda, latex y un diccionario con los parámetros de la ecuación.
Datos de ingreso
Los datos de ingreso son xi y yi para cada eje, la variable dígitosestablece los decimales a usar en la expresión en formato latex.
Datos de Salida
El resultado es un diccionario con los intervalos de los valores obtenidos para cada eje, la pendiente de la recta, el |error| promedio, la desviación estándar error_std, la ecuación en formato latex.
El resultado se puede escribir en un archivo en formato json. La ecuación se recupera desde el archivo con lo que se puede volver a construir la función en la lambda para evaluación numérica.
La relación rssi vs distancia usa log10(xi), por lo que se incluye esta operación antes de aplicar mínimos cuadrados.
Obtenidos los parámetros, se da el formato de la expresión acorde al modelo básico de pérdidas en espacio libre en latex para mostrar como etiqueta en las gráficas.
RSSI(d) = -10 \alpha \log_{10} (d) + P_{0}
La función se usa para cada baliza, y en varios segmentos, para observar los posibles resultados, también se incorporan los valores de errores,
Algoritmo en Python
def linealiza_lstsq(xi,yi,digitos = 3):
''' usa minimos cuadrados para entregar la ecuacion
digitos: usados en expresion latex
'''
unaecuacion = {}
# Eje x en log10()
xilog = np.log10(xi)
n = len(xi)
# mínimos cuadrados (least square),
# distancia vs medida
A = np.vstack([xilog, np.ones(n)]).T
[m0, b0] = np.linalg.lstsq(A, yi, rcond=None)[0]
alpha = -m0/10
beta = b0
# ecuaciones expresion rssi(d)
fdist0 = lambda d: -10*alpha*(np.log10(d))+beta
fdtxt0 = r'$ rssi = -10(' + str(np.round(alpha,digitos))
fdtxt0 = fdtxt0 + ')log_{10}(d)+('
fdtxt0 = fdtxt0 + str(np.round(beta,digitos))+')
Referencias: Burden R, Faires J, Burden A, Análisis numérico, Décima Edición 8.1 p370. Chapra C, Canale R. Métodos numéricos para ingenieros, Quinta edición 17.1.2 p469.
Usando las fórmulas encontradas para Rssi(d), usando intervalos y aplicando el algoritmo de trilateración se pueden obtener los siguientes resultados para el área de vegetación en FIEC:
los resultadosindican que se ubican puntos por al menos el 82.5% con errores promedio de 30 mts.
el detalle de los puntos encontrados se muestra en la tabla, donde la columna i*std indica si el radio para intersectar los círculos requería se añada i veces la desviación estándar. La columna "fuera" indica si la distancia fué calculada en una extensión del intervalo de la ecuación.
La cota de error se determina como la distancia máxima a los vértices del triángulo formado con la intersección de los círculos. La cota de error de puede comparar con el error real obtenido usando las coordenadas tomadas con un gps diferencial.
Como referencia para revisión de lo efectivo de la ecuación se añaden las columnas u_d# donde se indica si se usó el punto para generar la fórmula.
Errores localizacion
Errores estimado: Cota-Trilatera-polígono y Trilatera_vs_GPS
La trilateración se basa en determinar las posiciones relativas a objetos, para éste caso las balizas d1, d2 y d3 y mediante geometria encontrar el punto central de la intersección de los círculos generados por las posiciones relativas a cada objeto.
Para una baliza en particular, por ejemplo d2 en color naranja, la distancia relativa permite trazar un círculo a su alrededor. El círculo d2 se intersecta con los otros círculos d1 y d3 generando un área de intersección de tres puntos.
Los tres puntos forman un triángulo cuyo baricentro o centroide permite estimar la ubicación del punto "trilatera" a partir de las distancias relativas a balizas.
En la gráfica se añade la posición del dispositivo medida con un gps diferencial de mayor precisión, mostrando la cercanía entre los puntos.
Cota de Error
En concepto se puede establecer una cota de error a partir del baricentro de la intersección de los tres círculos.
Una forma conservadora toma la mayor distancia del baricentro a uno de los vértices. Observe que es una cota máxima, como un estimador del error máximo, valores que se comprobarían con los datos del experimento.
Las siguientes secciones desarrollan el algoritmo en Python para el concepto mostrado.
Los valores atípicos se los discrimina a partir de la desviación estándar, indicando el número de veces que se la considera como medida de dispersión.
Los puntos identificados en cada sector se seleccionan en 'grp': FIEC, FCNM, RECT.
El tipo de medición tomada, 'tip', se identifica por: punto, 1m, gtw, dispositivo.
Un parámetro auxiliar es 'LOS', que indica los puntos seleccionados con Línea de vista (1) y sin linea de vista (0). Para incluir todos de debe ingresar [1,0]. Este parámetro se puede modificar en el archivo de entrada: arch_medidaubica.
Los datos de cada eje se seleccionan mediante la función pares_usar(tabla, baliza, analiza, unabaliza, medida, modo) que entrega como resultado los arreglos de pares ordenados y las etiquetas con los nombres, par_etiqueta).
La linealización se realiza con el método de los mínimos cuadrados, con lo que se establece el |error| promedio y desviación estándar.
Para el análisis primero se consideran todos los puntos disponibles para obtener la primera ecuación, mostrada en el ejemplo con la línea azul.
Con ésto es posible determinar un error de estimación, para luego proceder a discriminar los puntos atípicos.
Se realiza una nueva estimación de linealización habiendo discriminado los puntos atípicos y se observa el resultado.
Resultados para baliza: gtwFIEC
El resultado del algoritmo se presenta como gráfica, en pantalla y un archivo con los datos de las fórmulas.
los resultados se pueden observar en lo mostrado.:
baliza: gtwFIEC
Puntos usados: todos
$ -10(4.908).log_{10}(d)+(1.406)$
|error| promedio: 4.84 , std: 5.56
Puntos usados: NoAtipico
$ -10(5.12).log_{10}(d)+(6.714)$
|error| promedio: 2.98 , std: 3.31
>>>
Se observa que los valores fuera de la banda de valores con una desviación estándar (σ) se muestran distribuidos en tres grupos: dos grupos a la izquierda y derecha de la gráfica por debajo de la banda y un grupo en el centro por sobre la banda.
Se considera explorar la división del intervalo en dos, puesto que existen dos entornos: uno principalmente conformado con vegetación y otro con edificaciones.
los resultados que se van al archivo, incluyen todos los decimales:
Los datos se leen desde el archivo y se incorporan a una estructura de datos en Pandas.
Para cada baliza se determina si se ha indicado 'analizar', con lo que se seleccionan los pares ordenados y etiquetas a usar mediante la función girni.pares_usar().
Con los datos seleccionados, se aplica mínimos cuadrados y se obtienen los errores mediante la función girni.linealiza_lstsq(). Mediante el criterio de desviación estándar se discriminan los datos atípicos y se vuelve a evaluar los datos sin atípicos, entregando el resultado mediante archivos y gráficas.
# LoRa-Multipunto, Rssi vs distancia
# linealización Rssi vs log10(distancia)
# por mínimos cuadrados, Graficas 2D y 3D
# Girni 2020-10-07 propuesta: edelros@espol.edu.ec
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import girni_lora_libreria as girni
# INGRESO
# archivos de entrada
modo = 'rx'
medida = 'rssi'
arch_medidaubica = 'resumen_rssiUbica01.txt'
# archivos de salida
arch_ecuaciones = 'resumen_ecuacionSimple05.json'
analiza = {'gtwRECT':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','RECT'],
'tip' : ['punto'],
'LOS' : [1,0]},
'gtwFIEC':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]},
'gtwFCNM':{'analizar' : 1,
'atipico_std' : 1,
'grp' : ['FIEC','FCNM'],
'tip' : ['punto'],
'LOS' : [1,0]}
}
baliza = {'d1':'gtwRECT',
'd2':'gtwFIEC',
'd3':'gtwFCNM'}
# Parámetros de grafica
tipograf = '2D' # '2D','3D'
escala = 'log' # 'normal','log'
escalabase = 10 # 10, np.exp()
# PROCEDIMIENTO
# Resultados de análisis
ecuacion = {}
eq_graf = {}
# leer datos
tabla = pd.read_csv(arch_medidaubica, index_col='etiqueta')
tabla = pd.DataFrame(tabla)
# Analizar datos hacia una baliza
for unabaliza in analiza:
# Parámetros
analizar = analiza[unabaliza]['analizar']
atipico_std = analiza[unabaliza]['atipico_std']
if analizar:
ecuacion[unabaliza] ={}
eq_graf[unabaliza] = {}
# pares a usar
[pares,par_etiqueta] = girni.pares_usar(tabla,baliza,
analiza,unabaliza,
medida,modo)
# analiza puntos para mínimos cuadrados
xi = pares[:,0]
yi = pares[:,1]
ecuacion0 = girni.linealiza_lstsq(xi,yi)
fdist0 = ecuacion0['eq_lambda']
yi0 = fdist0(xi)
# Selecciona atipicos
dyi0std = ecuacion0['error_std']
dyi0 = yi - yi0
atipicos = np.abs(dyi0) >= dyi0std*atipico_std
xi0_e = xi[atipicos]
yi0_e = yi[atipicos]
etiq0_e = par_etiqueta[atipicos]
# datos sin atipicos ----------
atipicoNo = np.abs(dyi0) <= dyi0std*atipico_std
xi1 = xi[atipicoNo]
yi1 = yi[atipicoNo]
etiq1 = par_etiqueta[atipicoNo]
ecuacion1 = girni.linealiza_lstsq(xi1,yi1)
fdist1 = ecuacion1['eq_lambda']
yi1 = fdist1(xi)
# para exportar
ecuacion[unabaliza] = {'todos': ecuacion0,
'NoAtipico': ecuacion1
}
eq_graf[unabaliza] = {'puntos': [xi,yi],
'todos' : yi0,
'atipicos':[xi0_e,yi0_e],
'atip_etiq': etiq0_e,
'NoAtipico':yi1
}
# SALIDA
for unabaliza in ecuacion:
print('baliza: ',unabaliza)
for unaecuacion in ecuacion[unabaliza]:
error_medio = ecuacion[unabaliza][unaecuacion]['error_medio']
error_std = ecuacion[unabaliza][unaecuacion]['error_std']
print('Puntos usados:', unaecuacion)
print(ecuacion[unabaliza][unaecuacion]['eq_latex'])
print('|error| promedio: ',np.round(error_medio,2),
' , std:',np.round(error_std,2))
print('\n',ecuacion[unabaliza],'\n')
print()
# salida a archivo
ecuacion = pd.DataFrame.from_dict(ecuacion)
ecuacion.to_json(arch_ecuaciones)
# GRAFICAR
# Referencias para gráfica
grupo = ['FIEC' ,'FCNM' ,'RECT','CIRC']
colores = ['green','orange','grey','magenta']
tipo = ['punto','1m' ,'gtw','dispositivo']
marcas = [ 'o','D' ,'D' ,'*' ]
mostrargrpeti = ['FIEC','FCNM','RECT']
mostrartipeti = ['1m','gtw']
for unabaliza in ecuacion:
figura,grafica = plt.subplots()
if escala == 'log':
grafica.set_xscale(escala,base=escalabase)
# todos los puntos
[xi, yi] = eq_graf[unabaliza]['puntos']
grafica.scatter(xi,yi,marker='.')
fdtxt = ecuacion[unabaliza]['todos']['eq_latex']
# linea con todos los puntos
yi0 = eq_graf[unabaliza]['todos']
grafica.plot(xi,yi0,color='blue', label = fdtxt)
[xi0_e,yi0_e] = eq_graf[unabaliza]['atipicos']
etiq0_e = eq_graf[unabaliza]['atip_etiq']
# cotas de error
atipico_std = analiza[unabaliza]['atipico_std']
dyi0std = ecuacion[unabaliza]['todos']['error_std']
grafica.plot(xi,yi0 + dyi0std*atipico_std,
color='blue',linestyle='dotted')
grafica.plot(xi,yi0 - dyi0std*atipico_std,
color='blue',linestyle='dotted')
# atipicos
grafica.scatter(xi0_e,yi0_e, color='red')
# atipicos etiquetas
m = len(xi0_e)
for i in range(0,m,1):
grafica.annotate(etiq0_e[i],
(xi0_e[i],yi0_e[i]),)
# linea Sin Atipicos
yi1 = eq_graf[unabaliza]['NoAtipico']
fdtxt1 = ecuacion[unabaliza]['NoAtipico']['eq_latex']
grafica.plot(xi,yi1, color='orange', label = fdtxt1)
# etiquetas y títulos
grafica.legend()
grafica.set_ylabel(medida+'_'+modo)
grafica.set_xlabel('distancia')
untitulo = unabaliza+': '+medida+'_'+modo + ' vs distancia'
grafica.set_title(untitulo)
grafica.grid(True,linestyle='dotted',
axis='x', which='both')
plt.show()
Para el modelo de perdidas de propagación, en cada punto se registra en el archivo las mediciones de Rssi y SNR. Cada archivo de datos procesan, tabulando y ordenando los valores representativos del comportamiento del RSSI y SNR para revisar sus descriptores de estadística.
Para realizar el procesamiento de los datos, se crearon algunas funciones y procedimientos para simplificar la escritura de instrucciones, las que se resumen en el archivo girni_lora_libreria.
Las coordenadas geográficas de dada punto se registraron con un GPS diferencial usando el formato UTM en un archivo tipo texto.
El procesamiento de los datos ser realiza en varios pasos donde se revisan los resultados parciales.
El primero de ellos consiste en tabular los datos de Rssi y SNR de cada punto en un solo archivo, luego se añaden las coordenadas y distancias cada punto medido, para finalmente integrar ambos resultados en un solo archivo con RSSI, distancias, coordenadas de cada punto.
Cada sección permite disponer de archivos intermedios que pueden ser usados para observar y procesar resultados que permitan realizar observaciones y mejoras a los modelos planteados. Entre los pasos intermedios está por ejemplo: observar en gráficas las ubicaciones de los puntos en el plano XY usando sus coordenadas, o en otro caso observar los valores de Rssi distribuidos en el espacio formado por el plano del ejemplo anterior y en el eje Z los valores promedios RSSI.
