{"id":2719,"date":"2020-11-21T12:46:33","date_gmt":"2020-11-21T17:46:33","guid":{"rendered":"http:\/\/blog.espol.edu.ec\/girni\/?p=2719"},"modified":"2021-12-30T11:49:24","modified_gmt":"2021-12-30T16:49:24","slug":"funciones-girni_lora_libreria","status":"publish","type":"post","link":"https:\/\/blog.espol.edu.ec\/girni\/funciones-girni_lora_libreria\/","title":{"rendered":"3.2 Funciones girni_lora_libreria"},"content":{"rendered":"

El archivo contiene un grupo de\u00a0 funciones usadas para procesar los datos de este prototipo, se separaron del bloque principal de instrucciones con\u00a0 el objetivo de simplificar el desarrollo del las actividades principales.<\/p>\n

Recuerde disponer de este archivo en la misma carpeta que el algoritmo que invoca a la librer\u00eda.<\/p>\n

archivo de libreria: girni_lora_libreria<\/a><\/p>\n

datos de muestras<\/h2>\n

tabulaPunto(unarchivo,directorio)<\/em><\/strong>:
\nLee el archivo de un punto, tabula cada lectura por dispositivo en diccionario,
\npor modo: rx, rx y remitente de cada paquete: baliza.<\/p>\n

describePunto(punto)<\/em><\/strong>:
\nestadistica descriptiva de un punto, calcula: count, mean, std, min, 25%, 50%, 75%, min, max<\/p>\n

resumen_medida(punto,medida,descriptor<\/strong><\/em>):
\nRealiza la tabla resumen de puntos por la medida y descriptor a partir de la tabla de los puntos estadisticos descritos<\/p>\n

Linealizaci\u00f3n para ecuaci\u00f3n<\/h2>\n

pares_usar<\/strong><\/em>(tabla<\/strong><\/em>, baliza<\/em><\/strong>, analiza<\/em><\/strong>,unabaliza<\/em><\/strong>, unsector ='', medida = 'rssi',modo = 'rx')<\/p>\n

Selecciona desde la tabla puntos a usar respecto a una baliza, el resultado se entrega en una lista que contiene los pares ordenados y sus etiquetas [pares, par_etiqueta]<\/p>\n

linealiza_lstsq<\/strong><\/em>(xi<\/strong><\/em>,yi<\/strong><\/em>,digitos = 3)
\nemplea el m\u00e9todo de minimos cuadrados para entregar la ecuacion mediante un diccionario que contiene los par\u00e1metros para aplicarla.<\/p>\n

La variable d\u00edgitos indica cu\u00e1ntos d\u00edgitos se usar\u00e1n para la ecuaci\u00f3n en formato latex.<\/p>\n

El procedimiento se describe en: Rssi(distancia) Linealizaci\u00f3n \u2013 funci\u00f3n Python<\/a><\/p>\n

unaecuacion = {'alpha'<\/span>   : alpha,\r\n               'beta'<\/span>    : beta,\r\n               'eq_latex'<\/span>: fdtxt0,\r\n               'intervalox'<\/span> : [np.min(xi),np.max(xi)],\r\n               'error_medio'<\/span>: dyi0mean,\r\n               'error_std'<\/span>  : dyi0std,\r\n               'eqg_latex'<\/span>  : grtxt0,\r\n               'intervaloy'<\/span>  : [np.min(yi),np.max(yi)],\r\n               'errorx_medio'<\/span>: dxi0mean,\r\n               'errorx_std'<\/span>  : dxi0std,\r\n               }\r\n<\/pre>\n
Proceso de triangulaci\u00f3n<\/h2>\n
dist_rssi<\/strong><\/em>(valor,ecuacion_rssi<\/em><\/strong>).\u00a0 Evalua la ecuacion de distancia(rssi) revisando los intervalos disponibles para el valor<\/strong> de rssi dado.<\/strong><\/p>\n
cruce2circulos<\/em><\/strong>(x1<\/em><\/strong>,y1<\/em><\/strong>,r1<\/strong><\/em>,x2,y2,r2). Revisa intervalo de area de cruce entre dos c\u00edrculos de centro y radio: x1, y1, r1 \/\/ x2, y2, r2.<\/p>\n
raices2circulos<\/em><\/strong>(x1<\/em>,y1<\/strong><\/em>,r1<\/strong><\/em>,x2,y2,r2,tolera=1e-10). Busca las intersecci\u00f3n entre 2 circulos de centro y radio: x1,y1,r1 || x2,y2,r2 . Revisa con cruce2circulos().<\/p>\n
intersectacirculos<\/strong><\/em>(radio<\/strong><\/em>,centro<\/strong><\/em>,tolera=1e-10). Busca las intersecciones entre parejas de varios c\u00edrculos y las entrega como [raicesx,raicesy], usa las funciones cruce2circulos() y con raices2circulos() que se encuentran en el enlace: Soluci\u00f3n General de intersecci\u00f3n de c\u00edrculos<\/a><\/p>\n
trilatera<\/strong><\/em>(radio<\/strong><\/em>,centro<\/strong><\/em>,tolera=1e-10). Busca el baricentro entre las intersecciones de varios c\u00edrculos, punto central en el \u00e1rea de
\nintersecci\u00f3n entre varios circulos. Requiere el resultado de la funci\u00f3n:
\nraiztodas = intersectacirculos(centro,radio, tolera = 1e-10)<\/p>\n
\n
Algoritmo Python<\/h2>\n
# Girni LoRa librerias 2020-10-07<\/span>\r\n# LoRa-Multipunto, lecturas de Rssi y SNR<\/span>\r\n# Girni 2020-10-07 propuesta: edelros@espol.edu.ec<\/span>\r\n\r\nimport<\/span> numpy as<\/span> np\r\nimport<\/span> pandas as<\/span> pd\r\nimport<\/span> scipy.optimize as<\/span> sp\r\n\r\ndef<\/span> tabulaPunto<\/span>(unarchivo,carpeta, prefijo = 'multipunto'<\/span>):\r\n    ''' Lee el archivo de un punto dentro del carpeta,\r\n        elimina el prefijo el nombre del archivo,\r\n        tabula cada lectura por dispositivo en diccionario,\r\n        por modo: rx, rx\r\n        y remitente de cada paquete: baliza\r\n        Prepara para procesar estadistica descriptiva\r\n    '''<\/span>\r\n    # Datos estructura<\/span>\r\n    punto = {'rx'<\/span>:{},\r\n             'tx'<\/span>:{},\r\n             'nombre'<\/span>: ' '<\/span>}\r\n    \r\n    # Lectura de unarchivo<\/span>\r\n    unarchivoubica = carpeta+'\/'<\/span>+unarchivo\r\n    archivoPunto = open<\/span>(unarchivoubica,'r'<\/span>)\r\n\r\n    # nombre del punto desde nombre archivo<\/span>\r\n    pnombre = unarchivo\r\n    pnombre = pnombre.strip('.txt'<\/span>)\r\n    n = len<\/span>(prefijo)\r\n    pnombre = pnombre[n:]\r\n    punto['nombre'<\/span>] = pnombre\r\n    \r\n    linea = archivoPunto.readline()\r\n    while<\/span> (linea!=''<\/span>):\r\n        linea_rx = linea.startswith('rx'<\/span>)\r\n        linea_tx = linea.startswith('tx'<\/span>)\r\n        if<\/span> linea_rx or<\/span> linea_tx:\r\n            # formato de trama:<\/span>\r\n            # tx_rx, c1_ff, d1_d2_d3, numtrama,<\/span>\r\n            # rssitx, snrtx, rssi_rx,snr_rx<\/span>\r\n            texto = linea.strip('\\n'<\/span>)\r\n            texto = texto.split(','<\/span>)\r\n            rx_tx      = texto[0]\r\n            dir_recibe = texto[1]\r\n            dir_remite = texto[2]\r\n            ID_paquete = int<\/span>(texto[3])\r\n            rssi_tx    = float<\/span>(texto[4])\r\n            snr_tx     = float<\/span>(texto[5])\r\n            rssi_rx    = float<\/span>(texto[6])\r\n            snr_rx     = float<\/span>(texto[7])\r\n            # llena datos<\/span>\r\n            if<\/span> dir_remite in<\/span> punto[rx_tx].keys():\r\n                punto[rx_tx][dir_remite]['rssi_rx'<\/span>].append(rssi_rx)\r\n                punto[rx_tx][dir_remite]['snr_rx'<\/span>].append(snr_rx)\r\n                punto[rx_tx][dir_remite]['secuencia_rx'<\/span>].append(ID_paquete)\r\n                punto[rx_tx][dir_remite]['rssi_tx'<\/span>].append(rssi_tx)\r\n                punto[rx_tx][dir_remite]['snr_tx'<\/span>].append(snr_tx)\r\n            else<\/span>:\r\n                punto[rx_tx][dir_remite] = {'rssi_rx'<\/span>: [rssi_rx],\r\n                                            'snr_rx'<\/span> : [snr_rx],\r\n                                            'secuencia_rx'<\/span>:[ID_paquete],\r\n                                            'rssi_tx'<\/span>: [rssi_tx],\r\n                                            'snr_tx'<\/span> : [snr_tx]}\r\n        # siguiente l\u00ednea<\/span>\r\n        linea = archivoPunto.readline()\r\n    archivoPunto.close()\r\n    return<\/span>(punto)\r\n\r\ndef<\/span> describePunto<\/span>(punto):\r\n    ''' estadistica descriptiva de un punto\r\n    calcula y registra count, mean, std,\r\n    min,25%,50%,75%,max\r\n    '''<\/span>\r\n    estadistica = {}\r\n    for<\/span> modo in<\/span> punto.keys():\r\n        estadistica[modo] = {}\r\n        # analiza rssi y snr para rx y tx<\/span>\r\n        for<\/span> disp in<\/span> punto[modo].keys():\r\n            estadistica[modo][disp] = ''<\/span>\r\n            valores = pd.DataFrame(punto[modo][disp])\r\n            descrito = valores.describe()\r\n            descrito = descrito.drop('secuencia_rx'<\/span>,axis=1)\r\n            estadistica[modo][disp] = descrito       \r\n    return<\/span>(estadistica)\r\n\r\n\r\ndef<\/span> resumen_medida<\/span>(punto,medida,descriptor):\r\n    '''\r\n    Realiza la tabla resumen de puntos por\r\n    medida ('rssi' o 'snr')\r\n    y descriptor ('count, mean, std,\r\n     min,25%,50%,75%,max)\r\n    a partir de la tabla de los puntos estadisticos descritos\r\n    '''<\/span>\r\n    rsm_disp = pd.DataFrame()\r\n    for<\/span> disp in<\/span> punto:\r\n        undisp_rx = punto[disp][medida+'_rx'<\/span>]\r\n        etiquetarx = medida+'_rx_'<\/span>+disp\r\n        rsm_disp[etiquetarx] = undisp_rx.copy()\r\n    for<\/span> disp in<\/span> punto:\r\n        undisp_tx = punto[disp][medida+'_tx'<\/span>]\r\n        etiquetatx = medida+'_tx_'<\/span>+disp\r\n        rsm_disp[etiquetatx] = undisp_tx.copy()\r\n    unafila = rsm_disp.loc[descriptor]\r\n    return<\/span>(unafila)\r\n\r\ndef<\/span> pares_usar<\/span>(tabla,baliza, analiza,\r\n                unabaliza, unsector =''<\/span>, \r\n                medida = 'rssi'<\/span>, modo = 'rx'<\/span>):\r\n    ''' Selecciona en tabla los puntos a usar\r\n        respecto a una baliza  y sector\r\n        resultado en [pares, par_etiqueta]\r\n    '''<\/span>\r\n    \r\n    # balizas referencia para analizar<\/span>\r\n    baliza_key = list<\/span>(baliza.keys())\r\n    baliza_val = list<\/span>(baliza.values())\r\n\r\n    donde = baliza_val.index(unabaliza)\r\n    cualbaliza = baliza_key[donde]\r\n\r\n    # banderas de uso y atipicos<\/span>\r\n    bal_sec = cualbaliza+unsector\r\n    tabla['usar_'<\/span>+bal_sec] = 0\r\n    tabla['atip_'<\/span>+bal_sec] = 0\r\n        \r\n    # Parametros<\/span>\r\n    if<\/span> unsector == ''<\/span>:\r\n        analizarque = analiza[unabaliza]\r\n    else<\/span>:\r\n        analizarque = analiza[unabaliza][unsector]\r\n    atipico_std = analizarque['atipico_std'<\/span>]\r\n    bal_grp = analizarque['grp'<\/span>]\r\n    bal_tip = analizarque['tip'<\/span>]\r\n    bal_LOS = analizarque['LOS'<\/span>]\r\n            \r\n    # usar segmento de grupo\/tipo, bandera True\/False<\/span>\r\n    for<\/span> cadapunto in<\/span> tabla.index:\r\n        cond1 = tabla['grupo'<\/span>][cadapunto] in<\/span> bal_grp\r\n        cond2 = tabla['tipo'<\/span>][cadapunto] in<\/span> bal_tip\r\n        cond3 = tabla['LOS_'<\/span>+cualbaliza][cadapunto] in<\/span> bal_LOS\r\n        cond4 = True<\/span>\r\n        if<\/span> unsector != ''<\/span>:\r\n            cond4 = tabla['sector_'<\/span>+cualbaliza][cadapunto] == int<\/span>(unsector.strip('s'<\/span>))\r\n        usar = cond1 and<\/span> cond2 and<\/span> cond3 and<\/span> cond4\r\n        valor = 0\r\n        if<\/span> usar:\r\n            valor = 1\r\n        tabla.loc[cadapunto,'usar_'<\/span>+bal_sec] = valor\r\n\r\n    # datos hacia baliza<\/span>\r\n    pares = []\r\n    par_etiqueta = []\r\n    for<\/span> cadapunto in<\/span> tabla.index:\r\n        columna = medida+'_'<\/span>+modo+'_'<\/span>+cualbaliza\r\n        xk = tabla['dist_'<\/span>+cualbaliza][cadapunto]\r\n        yk = tabla[columna][cadapunto]\r\n        \r\n        # no vacio y para usar<\/span>\r\n        cond1 = not<\/span>(np.isnan(yk))\r\n        cond2 = tabla['usar_'<\/span>+bal_sec][cadapunto]\r\n        if<\/span> cond1 and<\/span> cond2:\r\n            unpar = np.array([xk,yk])\r\n            \r\n            # llena pares y etiquetas<\/span>\r\n            if<\/span> len<\/span>(pares)>0:\r\n                pares = np.concatenate((pares,[unpar]),axis=0)\r\n                par_etiqueta = np.concatenate((par_etiqueta,[cadapunto]),\r\n                                              axis=0)\r\n            else<\/span>:\r\n                pares = np.array([unpar])\r\n                par_etiqueta = np.array([cadapunto])\r\n\r\n    # ordena pares para gr\u00e1fica<\/span>\r\n    if<\/span> len<\/span>(pares)>0:\r\n        ordenar = np.argsort(pares[:, 0])\r\n        pares = pares[ordenar]\r\n        par_etiqueta = par_etiqueta[ordenar]\r\n\r\n    return<\/span> ([pares, par_etiqueta])\r\n\r\ndef<\/span> linealiza_lstsq<\/span>(xi,yi,digitos = 3):\r\n    ''' usa minimos cuadrados para entregar la ecuacion\r\n        digitos: usados en expresion latex\r\n    '''<\/span>\r\n    unaecuacion = {}\r\n    # Eje x en log10()<\/span>\r\n    xilog = np.log10(xi)\r\n    n = len<\/span>(xi)\r\n    \r\n    # m\u00ednimos cuadrados (least square),<\/span>\r\n    # distancia vs medida<\/span>\r\n    A = np.vstack([xilog, np.ones(n)]).T\r\n    [m0, b0] = np.linalg.lstsq(A, yi, rcond=None<\/span>)[0]\r\n    alpha = -m0\/10\r\n    beta  = b0\r\n\r\n    # ecuaciones expresion rssi(d)<\/span>\r\n    fdist0 = lambda<\/span> d: -10*alpha*(np.log10(d))+beta\r\n    \r\n    fdtxt0 = r'$ rssi = -10('<\/span> + str<\/span>(np.round(alpha,digitos))\r\n    fdtxt0 = fdtxt0 + ')log_{10}(d)'<\/span> # +('<\/span>\r\n    texto = '+'<\/span>\r\n    if<\/span> beta <0:\r\n        texto = '-'<\/span>\r\n    fdtxt0 = fdtxt0 + texto + str<\/span>(np.round(np.abs(beta),digitos))+' $'<\/span>\r\n\r\n    # Errores respecto a rssi(d) <\/span>\r\n    yi0  = fdist0(xi)\r\n    dyi0 = yi - yi0\r\n    dyi0mean = np.mean(np.abs(dyi0))\r\n    dyi0std  = np.std(dyi0, dtype=np.float64)\r\n\r\n    # ecuaciones expresion d(rssi)<\/span>\r\n    grssi0 = lambda<\/span> rssi: 10**((beta-rssi)\/(10*alpha))\r\n    grtxt0 = r\"$ d = 10^{(\"<\/span> + str<\/span>(np.round(beta,digitos)) + ' - '<\/span>\r\n    grtxt0 = grtxt0 + 'rssi)\/'<\/span> + '(10('<\/span>+str<\/span>(np.round(alpha,digitos))+'))} $'<\/span>\r\n\r\n    # Errores respecto a rssi(d) <\/span>\r\n    xi0  = grssi0(yi)\r\n    dxi0 = xi - xi0\r\n    dxi0mean = np.mean(np.abs(dxi0))\r\n    dxi0std  = np.std(dxi0, dtype=np.float64)\r\n    \r\n    unaecuacion = {'alpha'<\/span>   : alpha,\r\n                   'beta'<\/span>    : beta,\r\n                   'eq_latex'<\/span>: fdtxt0,\r\n                   'intervalox'<\/span> : [np.min(xi),np.max(xi)],\r\n                   'error_medio'<\/span>: dyi0mean,\r\n                   'error_std'<\/span>  : dyi0std,\r\n                   'eqg_latex'<\/span>  : grtxt0,\r\n                   'intervaloy'<\/span> : [np.min(yi),np.max(yi)],\r\n                   'errorx_medio'<\/span>: dxi0mean,\r\n                   'errorx_std'<\/span>  : dxi0std,\r\n                   }\r\n    return<\/span>(unaecuacion)\r\n\r\ndef<\/span> dist_rssi<\/span>(valor,ecuacion_rssi, desplazar = 0):\r\n    ''' evalua ecuacion de distancia(rssi)\r\n        revisando los intervalos disponibles\r\n    '''<\/span>\r\n    # resultados<\/span>\r\n    distancia = np.nan\r\n    e_mean = np.nan\r\n    e_1std = np.nan\r\n    e_2std = np.nan\r\n    \r\n    # Revisa intervalos en ecuacion<\/span>\r\n    interv_fuera = 0\r\n    tamano = len<\/span>(ecuacion_rssi)\r\n    eq_cual = list<\/span>(ecuacion_rssi.keys())\r\n\r\n    # revisa si hay ecuaciones<\/span>\r\n    if<\/span> tamano >= 1:\r\n        # en intervalo de todos los puntos?<\/span>\r\n        i_eq = 'r0'<\/span>\r\n        a = ecuacion_rssi[i_eq]['intervaloy'<\/span>][0]\r\n        b = ecuacion_rssi[i_eq]['intervaloy'<\/span>][1]\r\n        desplaza = 0; valor0 = valor\r\n        if<\/span> 'desplaza'<\/span> in<\/span> list<\/span>(ecuacion_rssi[i_eq].keys()):\r\n            desplaza = ecuacion_rssi[i_eq]['desplaza'<\/span>]\r\n        if<\/span> desplazar == 1:\r\n            valor0 = valor - desplaza\r\n        if<\/span> valor0<a:\r\n            interv_fuera = -1 # izquierda<\/span>\r\n        if<\/span> valor0>=b:\r\n            interv_fuera = 1  # derecha<\/span>\r\n    if<\/span> interv_fuera!=0:\r\n        if<\/span> interv_fuera == 1: # derecha<\/span>\r\n            i_eq = eq_cual[1]\r\n        if<\/span> interv_fuera == -1: # izquierda<\/span>\r\n            i_eq = eq_cual[-1]\r\n        # intervalo rssi [a,b)<\/span>\r\n        a = ecuacion_rssi[i_eq]['intervaloy'<\/span>][0]\r\n        b = ecuacion_rssi[i_eq]['intervaloy'<\/span>][1]\r\n        alpha = ecuacion_rssi[i_eq]['alpha'<\/span>]\r\n        beta = ecuacion_rssi[i_eq]['beta'<\/span>]\r\n        # correccion de formula por desplazamiento<\/span>\r\n        desplaza = 0; valor1 = valor\r\n        if<\/span> 'desplaza'<\/span> in<\/span> list<\/span>(ecuacion_rssi[i_eq].keys()):\r\n            desplaza = ecuacion_rssi[i_eq]['desplaza'<\/span>]\r\n        if<\/span> desplazar == 1:\r\n            valor1 = valor - desplaza\r\n        distancia = 10**((valor1-beta)\/(-10*alpha))\r\n        \r\n        # errores estimados de distancia<\/span>\r\n        error_medio = ecuacion_rssi[i_eq]['error_medio'<\/span>]\r\n        error_std  = ecuacion_rssi[i_eq]['error_std'<\/span>]\r\n        dist_mean = 10**((valor-error_medio-beta)\/(-10*alpha))\r\n        dist_1std = 10**((valor-error_std-beta)\/(-10*alpha))\r\n        dist_2std = 10**((valor-2*error_std-beta)\/(-10*alpha))\r\n        e_mean = np.abs(distancia-dist_mean)\r\n        e_1std = np.abs(distancia-dist_1std)\r\n        e_2std = np.abs(distancia-dist_2std)\r\n\r\n    # evalua valor si hay ecuacion<\/span>\r\n    if<\/span> tamano>1 and<\/span> interv_fuera == 0:\r\n        donde = eq_cual.index('r0'<\/span>)\r\n        eq_cual.pop(donde)\r\n        # Revisa que exista ecuacion en cada intervalo<\/span>\r\n        for<\/span> i_eq in<\/span> eq_cual:\r\n            if<\/span> ecuacion_rssi[i_eq] is<\/span> None<\/span>:\r\n                donde = eq_cual.index(i_eq)\r\n                eq_cual.pop(donde)\r\n                \r\n        # revisa intervalo y evalua<\/span>\r\n        for<\/span> i_eq in<\/span> eq_cual:\r\n            # correccion de formula por desplazamiento<\/span>\r\n            desplaza = 0; valor1 = valor\r\n            if<\/span> 'desplaza'<\/span> in<\/span> list<\/span>(ecuacion_rssi[i_eq].keys()):\r\n                desplaza = ecuacion_rssi[i_eq]['desplaza'<\/span>]\r\n            if<\/span> desplazar == 1:\r\n                valor1 = valor - desplaza\r\n            # intervalo rssi [a,b)<\/span>\r\n            a = ecuacion_rssi[i_eq]['intervaloy'<\/span>][0]\r\n            b = ecuacion_rssi[i_eq]['intervaloy'<\/span>][1]\r\n            \r\n            cond1 = (valor1>=a) and<\/span> (valor1<b)\r\n            \r\n            if<\/span> cond1:\r\n                alpha = ecuacion_rssi[i_eq]['alpha'<\/span>]\r\n                beta = ecuacion_rssi[i_eq]['beta'<\/span>]\r\n                distancia = 10**((valor1-beta)\/(-10*alpha))\r\n                \r\n                # errores estimados de distancia<\/span>\r\n                error_medio = ecuacion_rssi[i_eq]['error_medio'<\/span>]\r\n                error_std  = ecuacion_rssi[i_eq]['error_std'<\/span>]\r\n                dist_mean = 10**((valor-error_medio-beta)\/(-10*alpha))\r\n                dist_1std = 10**((valor-error_std-beta)\/(-10*alpha))\r\n                dist_2std = 10**((valor-2*error_std-beta)\/(-10*alpha))\r\n                e_mean = np.abs(distancia-dist_mean)\r\n                e_1std = np.abs(distancia-dist_1std)\r\n                e_2std = np.abs(distancia-dist_2std)\r\n    \r\n    return<\/span>([distancia,e_mean,e_1std,e_2std,interv_fuera])\r\n\r\n# Las siguientes funciones tienen como objetivo<\/span>\r\n# realizar la trilateraci\u00f3n entre varios circulos<\/span>\r\n# def trilatera(radio,centro,tolera=1e-10)<\/span>\r\n# requieren las funiones:<\/span>\r\n# def cruce2circulos(x1,y1,r1,x2,y2,r2)<\/span>\r\n# def raices2circulos(x1,y1,r1,x2,y2,r2,tolera=1e-10)<\/span>\r\n# def intersectacirculos(radio,centro,tolera=1e-10)<\/span>\r\n\r\ndef<\/span> cruce2circulos<\/span>(x1,y1,r1,x2,y2,r2):\r\n    ''' Revisa intervalo de area de cruce\r\n        entre dos c\u00edrculos de centro y radio\r\n        x1,y1,r1 \/\/ x2,y2,r2\r\n    '''<\/span>\r\n    uncruce = []\r\n    dx = x2 - x1\r\n    dy = y2 - y1\r\n    d_centros = np.sqrt(dx**2 + dy**2)\r\n    d_cruce   = r2 + r1\r\n    \r\n    # los circulos se cruzan o tocan<\/span>\r\n    if<\/span> d_cruce >= d_centros:\r\n\r\n        # intervalos de cruce<\/span>\r\n        xa = np.max([x1-r1,x2-r2])\r\n        xb = np.min([x1+r1,x2+r2])\r\n        ya = np.max([y1-r1,y2-r2])\r\n        yb = np.min([y1+r1,y2+r2])\r\n        \r\n        # cada circulo arriba, abajo<\/span>\r\n        abajo1 = 0 ; arriba1 = 0\r\n        abajo2 = 0 ; arriba2 = 0\r\n        if<\/span> ya<=y1:\r\n            abajo1  = 1\r\n        if<\/span> yb>=y1:\r\n            arriba1 = 1\r\n        if<\/span> ya<=y2:\r\n            abajo2  = 1\r\n        if<\/span> yb>=y2:\r\n            arriba2 = 1\r\n        sector  = [ abajo1*abajo2, abajo1*arriba2,\r\n                   arriba1*abajo2, arriba1*arriba2]\r\n        uncruce = [xa,xb,ya,yb,sector]\r\n    return<\/span>(uncruce)\r\n\r\ndef<\/span> raices2circulos<\/span>(x1,y1,r1,x2,y2,r2,tolera=1e-10):\r\n    ''' busca las intersecci\u00f3n entre 2 circulos\r\n        de centro y radio: x1,y1,r1 || x2,y2,r2\r\n        revisa con cruce2circulos()\r\n    '''<\/span>\r\n    casicero = tolera*np.min([r1,r2])\r\n    uncruce = cruce2circulos(x1,y1,r1,x2,y2,r2)\r\n    raizx = []; raizy = []\r\n    secruzan =  0\r\n    \r\n    # si hay cruce de circulos<\/span>\r\n    if<\/span> len<\/span>(uncruce)>0:\r\n        sectores = [[-1,-1],[-1,1], \r\n                    [ 1,-1],[ 1,1]]\r\n        [xa,xb,ya,yb,sector] = uncruce\r\n        xc = (xa+xb)\/2\r\n        dx = xb-xa\r\n        dy = yb-ya\r\n        k = len<\/span>(sector)\r\n        if<\/span> dx<casicero: # se tocan en un punto<\/span>\r\n            k = 1\r\n        for<\/span> j in<\/span> range<\/span>(0,k,1):\r\n            if<\/span> sector[j]==1:\r\n                s1 = sectores[j][0]\r\n                s2 = sectores[j][1]\r\n                def<\/span> gx<\/span>(x,x1,r1,casicero):\r\n                    z = r1**2-(x-x1)**2\r\n                    if<\/span> np.abs(z)<casicero:\r\n                        z = 0\r\n                    return<\/span>(z)\r\n                fx1 = lambda<\/span> x: s1*np.sqrt(gx(x,x1,r1,casicero)) + y1\r\n                fx2 = lambda<\/span> x: s2*np.sqrt(gx(x,x2,r2,casicero)) + y2\r\n                fx  = lambda<\/span> x: fx1(x)-fx2(x)\r\n                \r\n                fa = fx(xa)\r\n                fb = fx(xb)\r\n                raiz1 = np.nan\r\n                raiz2 = np.nan\r\n                \r\n                # intervalo\/2 izquierda<\/span>\r\n                xc = xc + dx*tolera\r\n                fc = fx(xc)\r\n                cambio = np.sign(fa)*np.sign(fc)\r\n                if<\/span> cambio<0:\r\n                    raiz1 = sp.bisect(fx,xa,xc,xtol=tolera)\r\n                    \r\n                # intervalo\/2 derecha<\/span>\r\n                xc = xc - 2*dx*tolera\r\n                fc = fx(xc)\r\n                cambio = np.sign(fc)*np.sign(fb)\r\n                if<\/span> cambio<0:\r\n                    raiz2 = sp.bisect(fx,xc,xb,xtol=tolera)\r\n                    \r\n                # si hay contacto en un borde<\/span>\r\n                if<\/span> dx<casicero and<\/span> dy>0:\r\n                    raiz1 = xa\r\n                if<\/span> dy<casicero and<\/span> dx>0:\r\n                    raiz1 = x1\r\n                    \r\n                # A\u00f1ade si existe raiz<\/span>\r\n                if<\/span> not<\/span>(np.isnan(raiz1)):\r\n                    raizx.append(raiz1)\r\n                    raizy.append(fx1(raiz1))\r\n                if<\/span> not<\/span>(np.isnan(raiz2)):\r\n                    raizx.append(raiz2)\r\n                    raizy.append(fx1(raiz2))\r\n                secruzan = 1\r\n    # No hay cruce de circulos<\/span>\r\n    if<\/span> len<\/span>(uncruce) == 0:\r\n        dx = x2 - x1\r\n        dy = y2 - y1\r\n        m = dy\/dx\r\n        theta = np.arctan2(dy,dx)\r\n        dx1 = r1* np.cos(theta)\r\n        dx2 = r2* np.cos(theta)\r\n        xi1 = x1 + dx1\r\n        xi2 = x2 - dx2\r\n        b = y1 - m*x1\r\n        raizx = [(xi1+xi2)\/2]\r\n        raizy = [m*raizx[0]+b]\r\n        \r\n    raices = [raizx,raizy,secruzan]\r\n    return<\/span>(raices)\r\n\r\ndef<\/span> intersectacirculos<\/span>(radio,centro,tolera=1e-10):\r\n    ''' busca las intersecciones entre parejas de varios\r\n        c\u00edrculos y las entrega como [raicesx,raicesy]\r\n        usa las funciones cruce2circulos()\r\n        y con raices2circulos() que se encuentran en el enlace:\r\n    
s3Eva_IT2018_T1 Intersecci\u00f3n de dos c\u00edrculos<\/a><\/blockquote>