main

  1import pandas as pd, re, time, folium, os, shutil, tkinter as tk, sys, unicodedata
  2from opencage.geocoder import OpenCageGeocode
  3from folium.plugins import FastMarkerCluster
  4from pathlib import Path
  5from tkinter import filedialog
  6
  7
  8
  9# Declaración de variables globales
 10tipo_vía_urbana = ['CL', 'CR', 'AV', 'CIR', 'DG', 'TV']
 11keywords = tipo_vía_urbana.copy() + ['BIS', 'KM']
 12equivalente = {
 13    'CALLE' : 'CL',
 14    'CARRERA' : 'CR',
 15    'CRR' : 'CR',
 16    'CRA' : 'CR',
 17    'CLL' : 'CL',
 18    'NÚMERO' : '#',
 19    'NUMERO' : '#',
 20    'NO' : '#',
 21    'DIAGONAL' : 'DG',
 22    'CIRCULAR' : 'CIR',
 23    'TRANSVERSAL' : 'TV',
 24    'AVENIDA' : 'AV',
 25    'NO.' : '#',
 26    'NORTE' : 'N',
 27    'SUR' : 'S',
 28    'ESTE' : 'E',
 29    'ORIENTE' : 'E',
 30    'OESTE' : 'O',
 31    'OCCIDENTE' : 'O'
 32}
 33
 34área_metropolitana = [
 35    "MEDELLIN - ANTIOQUIA",
 36    "ITAGUI - ANTIOQUIA",
 37    "BELLO - ANTIOQUIA",
 38    "GIRARDOTA - ANTIOQUIA",
 39    "BARBOSA - ANTIOQUIA",
 40    "COPACABANA - ANTIOQUIA",
 41    "ENVIGADO - ANTIOQUIA",
 42    "SABANETA - ANTIOQUIA",
 43    "CALDAS - ANTIOQUIA",
 44    "LA ESTRELLA - ANTIOQUIA"
 45    ]
 46
 47barrios_medellin = [
 48    "ALDEA PABLO VI",
 49    "ALEJANDRIA",
 50    "ALEJANDRO ECHEVARRIA",
 51    "ALFONSO LOPEZ",
 52    "ALTAMIRA",
 53    "ALTAVISTA",
 54    "POBLADO",
 55    "ANDALUCIA",
 56    "ANTONIO NARINO",
 57    "ARANJUEZ",
 58    "ASOMADERA N1",
 59    "ASOMADERA N2",
 60    "ASOMADERA N3",
 61    "ASTORGA",
 62    "AURES N1",
 63    "AURES N2",
 64    "BARRIO CAICEDO",
 65    "BARRIO COLOMBIA",
 66    "BARRIO CRISTOBAL",
 67    "BARRIOS DE JESUS",
 68    "BELEN",
 69    "BELLO HORIZONTE",
 70    "BICENTENARIO",
 71    "BOSTON",
 72    "BOSQUES DE SAN PABLO",
 73    "BOMBONA N1",
 74    "BOMBONA N2",
 75    "BRASILIA",
 76    "BOSQUE",
 77    "BOLIVARIANA",
 78    "CALASANZ",
 79    "CALLE NUEVA",
 80    "CAMPO ALEGRE",
 81    "CAMPO AMOR",
 82    "CAMPO VALDES",
 83    "CANTV",
 84    "CANTAR",
 85    "CASTILLA",
 86    "CASTROPOL",
 87    "CATALUÑA",
 88    "CASTILLA",
 89    "CAICEDO",
 90    "CATEDRAL",
 91    "CARIBE",
 92    "CARLOS E. RESTREPO",
 93    "CARLOS E RESTREPO",
 94    "CENTRAL GARC",
 95    "CERRO EL VOLADOR",
 96    "CERRO NUTIBARA",
 97    "CHARCO MORALES",
 98    "CIELO",
 99    "COLON",
100    "COLONIA LIBRE",
101    "COLONIAL",
102    "COMUNA 1",
103    "COMUNA 13",
104    "COMUNA 4",
105    "COMUNA 7",
106    "CONDINA",
107    "CONQUISTADORES",
108    "CORAZON DE JESUS",
109    "CORAZON DE JESUS – BARRIO TRISTE",
110    "CÓRDOBA",
111    "CORTEXTO",
112    "CRISTO REY",
113    "DARE",
114    "DIEGO ECHEVARRIA",
115    "DOS QUETAZALES",
116    "EDUCACION",
117    "ESPINAL",
118    "ESTACION VILLA",
119    "ESTANCIA DEL MAR",
120    "ESTADIO",
121    "EUFEMIA CRUZ",
122    "EXPOSICION",
123    "FONTIBON",
124    "FERRINI",
125    "FLORENCIA",
126    "FLORIDA",
127    "FLORIDA NUEVA",
128    "FLORIDA VILLA",
129    "FUSIBLES",
130    "GENERAL MOTOBIEN",
131    "GENERAL PERON",
132    "GIRARDOT",
133    "GRANADA",
134    "GRANIZAL",
135    "GRANIZAL",
136    "GUAYABAL",
137    "HABSAÑA",
138    "HATILLO",
139    "HORIZONTES",
140    "HUNTER",
141    "HUMBERTO",
142    "JARDINES",
143    "JUAN PABLO II",
144    "JOSE JIMENEZ",
145    "LA AVANZADA",
146    "LA BARCALERA",
147    "LA BATERIA",
148    "LA CABAÑA",
149    "LA CASCADA",
150    "LA COLINA",
151    "LA COMUNA 1",
152    "LA COMUNA 2",
153    "LA ESPERANZA",
154    "LA FLORIDA",
155    "LA FRONTERA",
156    "LA GLORIA",
157    "LA HONDONADA",
158    "LA ISLA",
159    "LOMA DE LOS BERNAL",
160    "LA LOMA DE LOS ORIENTALES",
161    "LA MERCED",
162    "LA MOTA",
163    "LA PALMA",
164    "LA PARRANDA",
165    "LA PILARICA",
166    "LA PLAYA"
167]
168
169
170
171
172def main():
173    """
174    Función principal que maneja la interfaz de línea de comandos y coordina las funcionalidades disponibles:
175    1. Lectura y estandarización de direcciones.
176    2. Conversión de coordenadas usando reverse geocoding.
177    3. Mejora de coordenadas basadas en barrios.
178    4. Generación de mapas interactivos.
179    """
180    if len(sys.argv) == 2:
181        if sys.argv[1] == "c":
182            ruta_archivo = Path("llave") / "llave.txt"
183
184            llave = ""
185
186            with open(ruta_archivo, "r", encoding="utf-8") as archivo:
187                primera_linea = archivo.readline().strip()  # strip() elimina espacios al principio y al final
188
189            llave = primera_linea
190
191            ruta_archivo = Path("coordenadas") / "coordenadas.xlsx"
192
193            if os.path.exists(ruta_archivo):
194                df = pd.read_excel(ruta_archivo)
195            else:
196                df = pd.read_excel(Path("estandarizado") / "principales_área_metropolitana.xlsx")
197            am_vías_principales_coordenadas = reverse_geocoding(df.copy(), api_key=llave)
198            am_vías_principales_coordenadas.to_excel(Path("coordenadas") / "coordenadas.xlsx")
199
200            sys.exit()
201
202    estructura_programa()
203    verificar_y_copiar_archivo_original()
204    # Lectura de la base de datos
205    df = leer_archivo_original()
206    seleccion = int(seleccionar_funcionalidad())
207    match seleccion:
208        case 1:
209            # am -> área metropolitana
210            # nam -> no área metropolitana
211            a, b = filtrar_área_metropolitana(df)
212            am = pd.DataFrame(a)
213            nam = pd.DataFrame(b)
214            # Acondicionamiento básico de ambos DF
215            am.loc[:, "Direccion de residencia"] = reemplazar_equivalentes(am.loc[:, "Direccion de residencia"])
216            nam.loc[:, "Direccion de residencia"] = reemplazar_equivalentes(nam.loc[:, "Direccion de residencia"])
217
218            # Filtro de los tipos de vía principales en el DF am
219            am_vías_principales, am_vías_especiales = filtrar_vías_principales(am.copy())
220
221            # Estandarización direcciones
222            am_vías_principales = estandarización(am_vías_principales)
223    
224            am.to_excel(Path("estandarizado") / "total_área_metropolitana.xlsx")
225            am_vías_principales.to_excel(Path("estandarizado") / "principales_área_metropolitana.xlsx")
226            am_vías_especiales.to_excel(Path("estandarizado") / "especiales_área_metropolitana.xlsx")
227            nam.to_excel(Path("estandarizado") / "fuera_área_metropolitana.xlsx")
228
229        case 2:
230            ruta_archivo = Path("coordenadas") / "coordenadas.xlsx"
231            llave = obtener_llave()
232
233            if os.path.exists(ruta_archivo):
234                df = pd.read_excel(ruta_archivo)
235            else:
236                df = pd.read_excel(Path("estandarizado") / "principales_área_metropolitana.xlsx")
237            am_vías_principales_coordenadas = reverse_geocoding(df.copy(), api_key=llave)
238            am_vías_principales_coordenadas.to_excel(Path("coordenadas") / "coordenadas.xlsx")
239
240        case 3:
241            llave = obtener_llave()
242            ruta_archivo = Path("coordenadas") / "coordenadas.xlsx"
243            if os.path.exists(ruta_archivo):
244                df = pd.read_excel(ruta_archivo, index_col=0)
245            else:
246                sys.exit('Error: Necesitas primero procesar las coordenadas.')
247
248            coordenadas = rellenar_por_barrio(api_key=llave,df=df.copy())
249            coordenadas.to_excel(Path("coordenadas") / "coordenadas.xlsx")
250
251        case 4:
252            visualizar(pd.read_excel(Path('coordenadas') / 'coordenadas.xlsx'))
253
254
255def seleccionar_funcionalidad():
256    """
257    Muestra un menú interactivo para que el usuario seleccione la funcionalidad deseada.
258
259    Returns:
260        str: Número de la opción seleccionada ('1'-'4').
261    """
262    opciones = {
263        "1": "estandarización de direcciones",
264        "2": "conversión de coordenadas",
265        "3": "mejora de coordenadas (sólo si ya se realizó la conversión)",
266        "4": "generación de mapas"
267    }
268
269    print("Selecciona una funcionalidad:")
270    for clave, descripcion in opciones.items():
271        print(f"{clave}. {descripcion.capitalize()}")
272
273    while True:
274        seleccion = input("Ingresa el número de la opción deseada (1-4): ").strip()
275        if seleccion in opciones:
276            print(f"Has seleccionado: {opciones[seleccion].capitalize()}")
277            return seleccion
278        else:
279            print("Opción inválida. Por favor elige 1, 2, 3 o 4.")
280
281
282def verificar_y_copiar_archivo_original():
283    """
284    Verifica si la carpeta 'original' está vacía y, de ser así, permite al usuario seleccionar un archivo via diálogo
285    gráfico para copiarlo a dicha carpeta.
286    """
287    carpeta_original = Path("original")
288
289    # Verifica si está vacía
290    if not any(carpeta_original.iterdir()):
291        print("La carpeta 'original' está vacía. Selecciona un archivo para copiar allí.")
292
293        # Oculta la ventana principal de tkinter
294        root = tk.Tk()
295        root.withdraw()
296
297        # Abre el diálogo para seleccionar archivo
298        archivo_origen = filedialog.askopenfilename(title="Selecciona un archivo para copiar a 'original'")
299
300        if archivo_origen:
301            # Copia el archivo a la carpeta 'original'
302            archivo_destino = carpeta_original / Path(archivo_origen).name
303            shutil.copy(archivo_origen, archivo_destino)
304            print(f"Archivo copiado a: {archivo_destino}")
305        else:
306            print("No se seleccionó ningún archivo.")
307
308def estructura_programa():
309    """
310    Crea la estructura de directorios requerida por el programa si no existen.
311    """
312    rutas = [
313        Path("original"),
314        Path("estandarizado"),
315        Path("coordenadas"),
316        Path("mapas") / "filtrados",
317        Path("llave") / "llave.txt"
318    ]
319
320    for ruta in rutas:
321        # Si es un archivo (tiene sufijo como .txt), crea su carpeta padre
322        if ruta.suffix:
323            ruta.parent.mkdir(parents=True, exist_ok=True)
324        else:
325            ruta.mkdir(parents=True, exist_ok=True)
326
327def leer_archivo_original() -> pd.DataFrame:
328    """
329    Lee el único archivo presente en la carpeta 'original' y lo carga en un DataFrame.
330
331    Returns:
332        pd.DataFrame: Datos cargados desde el archivo Excel.
333    """
334    carpeta = Path("original")
335    archivos = list(carpeta.glob("*"))
336
337    # Filtrar solo archivos (ignora subdirectorios)
338    archivos = [f for f in archivos if f.is_file()]
339
340    if len(archivos) > 1:
341        print("Error: Hay más de un archivo en la carpeta 'original'. Asegúrate de que solo haya uno.")
342        sys.exit(1)
343
344    archivo = archivos[0]
345
346    # Leer el archivo Excel y devolver el DataFrame
347    df = pd.read_excel(archivo)
348    return df
349
350def obtener_llave():
351    """
352    Obtiene la llave API almacenada en 'llave/llave.txt', permite al usuario decidir usarla o ingresar una nueva,
353    y opcionalmente guarda la nueva llave para futuras ejecuciones.
354
355    Returns:
356        str: La llave API seleccionada o ingresada.
357    """
358
359    # Ruta del archivo
360    ruta_archivo = Path("llave") / "llave.txt"
361
362    # Asegura que el directorio existe
363    os.makedirs(os.path.dirname(ruta_archivo), exist_ok=True)
364
365    llave = ""
366
367
368    # Paso 1: Verificar si el archivo existe y leer la primera línea
369    if os.path.exists(ruta_archivo):
370        with open(ruta_archivo, "r", encoding="utf-8") as archivo:
371            primera_linea = archivo.readline().strip()  # strip() elimina espacios al principio y al final
372
373        if primera_linea:
374            previa = input("Se encontró una llave en el sistema de una ejecución previa, ¿Desea usarla? (s/n): ").strip().lower()
375            if previa == "s":
376                llave = primera_linea
377            else:
378                llave = input("Ingresa una llave: ").strip()
379                guardar = input("¿Deseas guardar esta llave para la próxima ejecución? (s/n): ").strip().lower()
380                if guardar == "s":
381                    with open(ruta_archivo, "w", encoding="utf-8") as archivo:
382                        archivo.write(llave + "\n")
383        else:
384            # No hay contenido válido en la primera línea
385            llave = input("No se encontró una llave válida. Ingresa una llave: ").strip()
386            guardar = input("¿Deseas guardar esta llave para la próxima ejecución? (s/n): ").strip().lower()
387            if guardar == "s":
388                with open(ruta_archivo, "w", encoding="utf-8") as archivo:
389                    archivo.write(llave + "\n")
390    else:
391        # El archivo no existe
392        llave = input("No se encontró el archivo de llave. Ingresa una llave: ").strip()
393        guardar = input("¿Deseas guardar esta llave para la próxima ejecución? (s/n): ").strip().lower()
394        if guardar == "s":
395            with open(ruta_archivo, "w", encoding="utf-8") as archivo:
396                archivo.write(llave + "\n")
397
398    # Mostrar la llave obtenida
399    return llave
400
401
402def filtrar_área_metropolitana(df : pd.DataFrame) -> pd.DataFrame:
403    """
404    Separa el DataFrame en dos listas:
405    - Registros cuya 'Ciudad Residencia' pertenece al área metropolitana.
406    - Registros fuera de dicha área.
407
408    Args:
409        df (pd.DataFrame): DataFrame original con columna 'Ciudad Residencia'.
410
411    Returns:
412        list: [DataFrame_area_metropolitana, DataFrame_fuera_area]
413    """
414    a = df.loc[df["Ciudad Residencia"].isin(área_metropolitana)]
415    return [a, df[~df["Ciudad Residencia"].isin(a["Ciudad Residencia"])]]
416    
417
418def reemplazar_equivalentes(s : pd.Series) -> pd.Series:
419    """
420    Reemplaza en una Serie de direcciones las palabras clave por sus equivalentes abreviados.
421
422    Args:
423        s (pd.Series): Serie de strings con direcciones.
424
425    Returns:
426        pd.Series: Serie con direcciones normalizadas en mayúsculas y abreviadas.
427    """
428    s = s.apply(str.upper)
429    for i in equivalente:
430        s = s.str.replace(i, equivalente[i])
431    return s 
432
433
434def filtrar_vías_principales(df : pd.DataFrame):
435    """
436    Filtra el DataFrame para separar las direcciones que comienzan con un tipo de vía principal.
437
438    Args:
439        df (pd.DataFrame): DataFrame con columna 'Direccion de residencia'.
440
441    Returns:
442        list: [DataFrame_principales, DataFrame_especiales]
443    """
444    s = identificar_vías_principales(pd.Series(df.loc[:, "Direccion de residencia"].copy()))
445    s.dropna(inplace=True)
446
447    index_drop = list((set(df.index.copy()) - set(s.index.copy())))
448    new_df = df.drop(index_drop, inplace=False)
449
450    return [new_df, df[~df["Direccion de residencia"].isin(new_df["Direccion de residencia"])]]
451
452
453def identificar_vías_principales(s : pd.Series) -> pd.Series:
454    """
455    Identifica si cada dirección en la Serie comienza con un tipo de vía definido en 'tipo_vía_urbana'.
456
457    Args:
458        s (pd.Series): Serie de strings con direcciones.
459
460    Returns:
461        pd.Series: Serie con el código de vía o None si no coincide.
462    """
463    s = s.copy()
464    for i in s.index:
465        for vía in tipo_vía_urbana:
466            if str(s.loc[i]).startswith(vía):
467                s.loc[i] = vía
468                break
469        if s.loc[i] not in tipo_vía_urbana:
470            s.loc[i] = None
471
472    #Esta función retorna una serie que tiene el tipo de vía de una dirección o un valor nulo en 
473    # caso de que no cumpla esta condición 
474    return s
475
476def estandarización(df : pd.DataFrame):
477    """
478    Aplica procesamiento de estandarización de direcciones y añade la columna 'Complemento'.
479
480    Args:
481        df (pd.DataFrame): DataFrame con columna 'Direccion de residencia'.
482
483    Returns:
484        pd.DataFrame: DataFrame estandarizado con nueva columna 'Complemento'.
485    """
486    añadir_columna_complemento(df)
487    df.loc[:, "Direccion de residencia"] = df.loc[:, "Direccion de residencia"].apply(format_dir)
488    
489    # Reordenar columnas: mover "Complemento" al lado de "Direccion de residencia"
490    columnas = df.columns.tolist()
491    if "Complemento" in columnas and "Direccion de residencia" in columnas:
492        columnas.remove("Complemento")
493        idx = columnas.index("Direccion de residencia") + 1
494        columnas.insert(idx, "Complemento")
495        df = df[columnas]
496    return df
497
498def añadir_columna_complemento(df : pd.DataFrame):
499    """
500    Separa la dirección en base al complemento y añade la columna 'Complemento' al DataFrame.
501
502    Args:
503        df (pd.DataFrame): DataFrame con columna 'Direccion de residencia'.
504    """
505    df.loc[:, "Direccion de residencia"] =df.loc[:, "Direccion de residencia"].apply(dividir_complemento)
506    buffer = []
507    for i in df.index:
508        buffer.append(df.loc[i, "Direccion de residencia"][1])
509        df.loc[i, "Direccion de residencia"] = df.loc[i, "Direccion de residencia"][0]
510    df["Complemento"] = buffer
511
512
513def dividir_complemento(s : str):
514    """
515    Divide una dirección en parte principal y complemento basado en palabras clave.
516
517    Args:
518        s (str): Dirección completa.
519
520    Returns:
521        list: [parte_principal, complemento]
522    """
523    delay = 0
524    try:
525        for i in range(len(s)):
526            if delay == 0:
527                if ((s[i]+s[i + 1]) in keywords and not s[i + 2].isalpha()):
528                    delay = 2
529                elif (s[i]+s[i + 1]+s[i + 2]) in keywords and not s[i + 3].isalpha():
530                    delay = 3
531                else:
532                    if s[i].isalpha() and s[i + 1].isalpha():
533                        if s[i] != s[i + 1]:
534                            new_str = s.split(s[i] + s[i + 1], 1)
535                            new_str[1] = (s[i] + s[i + 1] + new_str[1]).strip()
536                            new_str[0] = new_str[0].strip()
537                            return new_str
538            else:
539                delay -= 1
540    except IndexError:
541        return [s, '']
542    
543def format_dir(s):
544    """
545    Formatea una dirección separando componentes de vía, números y complementos.
546
547    Args:
548        s (str): Dirección sin formato.
549
550    Returns:
551        str: Dirección formateada.
552    """
553    matches = re.findall(r'([A-ZÑ]+|\d+)', s)
554
555    temp = ''
556    part = 0
557    num_aldready = False
558    letter_aldready = False
559    via_aldready = False
560
561    for match in matches:
562        if match in tipo_vía_urbana:
563            if not via_aldready:
564                temp = temp + f'{match} '
565                via_aldready = True
566        elif match in keywords:
567            temp = temp + f'{match} ' if temp.endswith(' ') or temp == '' else temp + f' {match} '
568        elif match.isnumeric():
569            if num_aldready:
570                part += 1
571                match part:
572                    case 1:
573                        temp = temp = temp + '#' if temp.endswith(' ') else temp + ' #'
574                    case 2:
575                        temp = temp = temp + '-'
576                num_aldready = False
577                letter_aldready = False
578            temp = temp + f'{match}'
579            num_aldready = True
580        else:
581            temp = temp + f'{match}' if not letter_aldready else temp + f' {match}'
582            letter_aldready = True
583    
584    return temp
585
586
587
588def reverse_geocoding(df: pd.DataFrame, api_key: str, n = 300) -> pd.DataFrame:
589    """
590    Realiza reverse geocoding sobre un número exacto de registros (n), partiendo desde:
591    - El primer registro si no existen columnas 'Latitud' y 'Longitud'.
592    - El primer registro donde 'Latitud' o 'Longitud' están vacíos, si ya existen.
593
594    Se realiza una consulta por segundo (como exige la API de OpenCage).
595    """
596    geocoder = OpenCageGeocode(api_key)
597
598    # Crear columnas si no existen
599    if 'Latitud' not in df.columns:
600        df['Latitud'] = None
601    if 'Longitud' not in df.columns:
602        df['Longitud'] = None
603
604    # Encontrar primer índice donde falta alguna coordenada
605    start_idx = None
606    for idx in df.index:
607        if pd.isna(df.at[idx, 'Latitud']) or pd.isna(df.at[idx, 'Longitud']):
608            start_idx = idx
609            break
610
611    if start_idx is None:
612        print("Todas las coordenadas ya están completas. No se necesita geocodificación.")
613        return df
614
615    # Geocodificar exactamente n registros desde start_idx
616    processed = 0
617    for idx in df.loc[start_idx:].index:
618        if processed >= n:
619            break
620
621        direccion = f"{df.at[idx,'Direccion de residencia']}, {df.at[idx,'Ciudad Residencia'].replace(' -',',')}, Antioquia, Colombia"
622
623        try:
624            resultados = geocoder.geocode(direccion, no_annotations=1, countrycode='co')
625        except Exception as e:
626            print(f"‼ Error al consultar idx={idx}: {e}")
627            continue
628
629        if resultados and len(resultados):
630            df.at[idx, 'Longitud'] = resultados[0]['geometry']['lng']
631            df.at[idx, 'Latitud']  = resultados[0]['geometry']['lat']
632        else:
633            df.at[idx, 'Longitud'] = geocoder.geocode(df.at[idx,'Ciudad Residencia'].replace(' -',',')
634                                                      , no_annotations=1, countrycode='co')[0]['geometry']['lng']
635            df.at[idx, 'Latitud']  = geocoder.geocode(df.at[idx,'Ciudad Residencia'].replace(' -',',')
636                                                      , no_annotations=1, countrycode='co')[0]['geometry']['lat']
637
638        processed += 1
639        print(f"✓ Coordenadas asignadas en fila {idx}\nRegistros procesados: {processed}")
640        time.sleep(1)
641
642    # Reordenar columnas si existe 'Complemento'
643    cols = df.columns.tolist()
644    if 'Complemento' in cols:
645        idx_comp = cols.index('Complemento')
646        geo_cols = ['Latitud', 'Longitud']
647        for col in geo_cols:
648            if col in cols:
649                cols.remove(col)
650        cols = cols[:idx_comp+1] + geo_cols + cols[idx_comp+1:]
651        df = df[cols]
652
653    return df
654
655
656def visualizar(df : pd.DataFrame):
657    """
658    Genera y guarda mapas HTML con marcadores y clusters basados en coordenadas del DataFrame.
659
660    Args:
661        df (pd.DataFrame): DataFrame con columnas 'Latitud' y 'Longitud'.
662    """
663    df.dropna(subset=['Latitud', 'Longitud'], inplace=True)
664    latitudes = [a['Latitud'] for a in df.to_dict('records')]
665    longitudes = [a['Longitud'] for a in df.to_dict('records')]
666    data = list(zip(latitudes, longitudes))
667
668    map = folium.Map(location=[6.2464186, -75.5942503], zoom_start=12)
669    for a in df.index:
670        coordenada = (df['Latitud'][a], df['Longitud'][a])
671        folium.Marker(coordenada).add_to(map)
672
673    map2 = folium.Map(location=[6.2464186, -75.5942503], zoom_start=12)
674
675    FastMarkerCluster(data=data).add_to(map2)
676
677    map.save(Path('mapas') / 'individual.html')
678    map2.save(Path('mapas') / 'clusters.html')
679
680    df_filtrado = df[
681        ~((df["Latitud"] == 6.25184) & (df["Longitud"] == -75.56359))
682    ]
683    latitudes = [a['Latitud'] for a in df_filtrado.to_dict('records')]
684    longitudes = [a['Longitud'] for a in df_filtrado.to_dict('records')]
685    data = list(zip(latitudes, longitudes))
686
687    map = folium.Map(location=[6.2464186, -75.5942503], zoom_start=12)
688    for a in df_filtrado.index:
689        coordenada = (df_filtrado['Latitud'][a], df_filtrado['Longitud'][a])
690        folium.Marker(coordenada).add_to(map)
691
692    map2 = folium.Map(location=[6.2464186, -75.5942503], zoom_start=12)
693
694    FastMarkerCluster(data=data).add_to(map2)
695
696    map.save(Path('mapas') / "filtrados" / 'individual_filtrados.html')
697    map2.save(Path('mapas') / "filtrados" / 'clusters_filtrados.html')
698
699
700def rellenar_por_barrio(df: pd.DataFrame,
701                        api_key: str,
702                        n = 400) -> pd.DataFrame:
703    """
704    Para registros con lat=6.25184 y lon=-75.56359 y Complemento conteniendo
705    un barrio de barrios_medellin, re-geocodifica usando Ciudad + Barrio.
706    No hace más de n llamadas al API.
707    """
708    geocoder = OpenCageGeocode(api_key)
709    llamadas = 0
710
711    latitud = df['Latitud'].copy()
712    longitud = df["Longitud"].copy()
713
714    # Preprocesar lista de barrios: sin tildes y en mayúsculas
715    def normaliza(texto: str) -> str:
716        # Quita tildes
717        s = unicodedata.normalize('NFD', texto)
718        s = ''.join(ch for ch in s if unicodedata.category(ch) != 'Mn')
719        return s.upper()
720
721
722    for idx, row in df.iterrows():
723        if llamadas >= n:
724            break
725
726        lat = row.get('Latitud', None)
727        lon = row.get('Longitud', None)
728        complemento = row.get('Complemento', '')
729        if lat == 6.25184 and lon == -75.56359:
730            comp_norm = normaliza(str(complemento))
731            # ¿Algún barrio está contenido en el texto normalizado?
732            barrio_encontrado = next((b for b in barrios_medellin if b in comp_norm), None)
733            if barrio_encontrado:
734                # Construir dirección: ciudad + barrio
735                direccion = f"{barrio_encontrado}, MEDELLIN"
736
737                try:
738                    resultados = geocoder.geocode(direccion, no_annotations=1, countrycode='co')
739                except Exception as e:
740                    print(f"‼ Error al geocodificar idx={idx}: {e}")
741                    continue
742
743                if resultados and len(resultados):
744                    longitud.loc[idx] = resultados[0]['geometry']['lng']
745                    latitud.loc[idx]  = resultados[0]['geometry']['lat']
746                    print(f"✓ Re-geocodificado idx={idx} → {barrio_encontrado}")
747                else:
748                    print(f"– Sin resultados para idx={idx}, barrio={barrio_encontrado}")
749
750                llamadas += 1
751                time.sleep(1)  # pausa mínima entre llamadas
752
753    df["Latitud"] = latitud
754    df["Longitud"] = longitud
755    if llamadas == 0:
756        print("Los registros han sido optimizados")
757    else:
758        print(f"🗸 Total de llamadas realizadas: {llamadas}")
759    return df
760    
761
762if __name__ == "__main__":
763    main()