import os

import pandas as pd
import numpy as np
import [Link] as plt
from sklearn.linear_model import LinearRegression
from [Link] import mean_squared_error

# Función para guardar los promedios de bandas y ND en un archivo Excel

def guardar_promedios_en_excel(promedios_bandas_negro, promedios_bandas_blanco,
promedios_nd_negro, promedios_nd_blanco, ruta_guardado):
# Convert dictionaries to DataFrames
df_bandas_negro = [Link]([promedios_bandas_negro])
df_bandas_blanco = [Link]([promedios_bandas_blanco])
df_nd_negro = [Link]([promedios_nd_negro])
df_nd_blanco = [Link]([promedios_nd_blanco])

# Save DataFrames to an Excel file

with [Link]([Link](ruta_guardado,
'promedios_totales_bandas.xlsx')) as writer:
df_bandas_negro.to_excel(writer, sheet_name='Promedios_Bandas_Negro',
index=False)
df_bandas_blanco.to_excel(writer, sheet_name='Promedios_Bandas_Blanco',
index=False)
df_nd_negro.to_excel(writer, sheet_name='Promedios_ND_Negro', index=False)
df_nd_blanco.to_excel(writer, sheet_name='Promedios_ND_Blanco',
index=False)

# Crear el DataFrame de promedios de bandas

df_bandas = [Link]({
'Banda': ['Banda Verde', 'Banda Roja', 'Banda Borde Rojo', 'Banda
Infrarrojo Cercano'],
'Promedio_Negro': [Link](promedios_bandas_negro),
'Promedio_Blanco': [Link](promedios_bandas_blanco)
})

# Crear el DataFrame de promedios ND

df_nd = [Link]({
'Banda': ['Banda Verde', 'Banda Roja', 'Banda Borde Rojo', 'Banda
Infrarrojo Cercano'],
'Promedio_ND_Negro': [Link](promedios_nd_negro),
'Promedio_ND_Blanco': [Link](promedios_nd_blanco)
})

# Guardar los DataFrames en un archivo Excel

with [Link]([Link](ruta_guardado,
'promedios_totales_bandas.xlsx')) as writer:
df_bandas.to_excel(writer, sheet_name='Promedios_Bandas', index=False)
df_nd.to_excel(writer, sheet_name='Promedios_ND', index=False)

# Función para calcular el promedio de reflectancia en cada archivo .TRM

def calcular_promedio_archivos_de_carpeta(carpeta):
columnas = []
primera_columna = None
archivos_trm = [f for f in [Link](carpeta) if [Link]('.TRM')]

if len(archivos_trm) == 0:
print(f"No se encontraron archivos .TRM en la carpeta: {carpeta}")
return None
 for idx, archivo in enumerate(archivos_trm):
ruta_archivo = [Link](carpeta, archivo)
with open(ruta_archivo, 'r') as file:
lineas = [Link]()[2:] # Elimina las dos primeras filas

datos_procesados = []
for linea in lineas:
partes = [Link]()
if len(partes) > 1:
datos_procesados.append([float(valor) for valor in partes])
else:
raise ValueError(f"El archivo {archivo} no está correctamente
separado por espacios en la línea: {linea}")

df_temp = [Link](datos_procesados)

if idx == 0:
primera_columna = df_temp.iloc[:, 0]
if df_temp.shape[1] > 1:
[Link](df_temp.iloc[:, 1])
else:
raise ValueError(f"El archivo {archivo} no tiene suficientes
columnas.")

if len(columnas) == 0:
raise ValueError("No hay columnas válidas para promediar")

df_promedio = [Link]()
df_promedio['Longitud_Onda'] = primera_columna
df_promedio['Promedio_Reflectancia'] = [Link](columnas, axis=1).mean(axis=1)

return df_promedio

# Función para guardar los promedios de bandas

def guardar_por_banda(df_promedio, nombre_carpeta, es_objeto_negro=True):
bandas = {
'Verde': (544, 576),
'Roja': (634, 666),
'Borde_Rojo': (714, 746),
'Infrarrojo_Cercano': (834, 886)
}

promedios_banda = {}

for nombre_banda, (min_onda, max_onda) in [Link]():

datos_banda = df_promedio[(df_promedio['Longitud_Onda'] >= min_onda) &
(df_promedio['Longitud_Onda'] <= max_onda)]

if datos_banda.empty:
print(f"Warning: No data found for {nombre_banda} in {nombre_carpeta}.
Skipping...")
promedio_banda = [Link]
else:
promedio_banda = datos_banda['Promedio_Reflectancia'].mean()

promedios_banda[f'Promedio_{nombre_banda}'] = promedio_banda

promedios_banda[nombre_banda] = promedio_banda # Store in dictionary

 return promedios_banda # Return the dictionary

# Función para cargar archivos ND y calcular promedios

def cargar_archivo_nd(ruta_archivo, nombre):

df_nd = pd.read_excel(ruta_archivo)

# Asegurarse de que los valores sean numéricos

df_nd['BANDA_1'] = pd.to_numeric(df_nd['BANDA_1'], errors='coerce')
df_nd['BANDA_2'] = pd.to_numeric(df_nd['BANDA_2'], errors='coerce')
df_nd['BANDA_3'] = pd.to_numeric(df_nd['BANDA_3'], errors='coerce')
df_nd['BANDA_4'] = pd.to_numeric(df_nd['BANDA_4'], errors='coerce')

# Calcular los promedios

promedios_nd = {
'Banda_Roja': df_nd['BANDA_1'].mean(),
'Banda_Verde': df_nd['BANDA_2'].mean(),
'Banda_Borde_Rojo': df_nd['BANDA_3'].mean(),
'Banda_Infrarrojo_Cercano': df_nd['BANDA_4'].mean()
}

# Guardar los promedios en un archivo de Excel

directorio_salida = [Link](ruta_archivo)
[Link](directorio_salida, exist_ok=True)

ruta_excel_nd = [Link](directorio_salida, f'Promedios_ND_{nombre}.xlsx')

[Link]([promedios_nd]).to_excel(ruta_excel_nd, index=False)
print(f"Archivo Excel de promedios ND guardado en {ruta_excel_nd}")

return promedios_nd

# Función para generar las gráficas de regresión conjunta

def generar_graficas_regresion_conjunta(ruta_excel, ruta_guardado):
"""Generates linear regression plots and saves equations to Excel."""
try:
# Load data from Excel sheets
df_bandas = pd.read_excel(ruta_excel, sheet_name='Promedios_Bandas')
df_nd = pd.read_excel(ruta_excel, sheet_name='Promedios_ND')

# Create a list to store the equations

ecuaciones = []

# Iterate through each band (row)

for i in range(len(df_bandas)):
# Get data for the current band - SWAPPED x and y
x_vals = [[df_nd.loc[i, 'Promedio_ND_Negro']], [df_nd.loc[i,
'Promedio_ND_Blanco']]] # Nested lists
y_vals = [df_bandas.loc[i, 'Promedio_Negro'], df_bandas.loc[i,
'Promedio_Blanco']]

# Perform linear regression

modelo = LinearRegression()
[Link](x_vals, y_vals)

# Calculate predictions and RMSE

y_pred = [Link](x_vals)
error_rmse = [Link](mean_squared_error(y_vals, y_pred))
 # Format equation and RMSE for the legend
ecuacion = f'y = {modelo.coef_[0]:.8f}x + {modelo.intercept_:.8f}'
rmse_str = f'{error_rmse:.2e}'.replace('e', ' x 10^') # Format RMSE

# Append the equation to the list

[Link]({'Banda': df_bandas.loc[i, 'Banda'], 'Ecuacion':
ecuacion})

# Generate and save the plot

[Link]()
[Link](x_vals, y_vals, color='blue', label='Datos Observados')
[Link](x_vals, y_pred, color='red', label=f'{ecuacion}\nRMSE:
{rmse_str}')
[Link]('Valor ND (Negro/Blanco)') # Changed label
[Link]('Reflectancia Promedio (Negro/Blanco)') # Changed label
[Link](f'Regresión para {df_bandas.loc[i, "Banda"]}')
[Link]()
[Link](True)

[Link](ruta_guardado, exist_ok=True)
ruta_grafica = [Link](ruta_guardado,
f'Regresion_{df_bandas.loc[i, "Banda"]}.png')
[Link](ruta_grafica)
[Link]()
print(f"Gráfica de regresión guardada en: {ruta_grafica}")

# Save equations to Excel

df_ecuaciones = [Link](ecuaciones)
ruta_ecuaciones = [Link](ruta_guardado, 'Ecuaciones_Regresion.xlsx')
df_ecuaciones.to_excel(ruta_ecuaciones, index=False)
print(f"Ecuaciones de regresión guardadas en: {ruta_ecuaciones}")

except FileNotFoundError:
print(f"Error: No se encontró el archivo Excel en la ruta: {ruta_excel}")
except Exception as e:
print(f"Error durante la regresión: {e}")

# Función para procesar las subcarpetas

def procesar_subcarpetas(carpeta_raiz, ruta_guardado, ruta_objeto_negro,
ruta_objeto_blanco):
subcarpetas = [f for f in [Link](carpeta_raiz) if
[Link]([Link](carpeta_raiz, f))]

# Find the actual Excel files for ND data

archivos_excel = [f for f in [Link](carpeta_raiz) if [Link]('.xlsx')
and not [Link]('~$')] # Exclude temporary files

# Assuming there are two Excel files, one for negro and one for blanco
if len(archivos_excel) != 2:
raise ValueError("Expected two Excel files (one for negro and one for
blanco) in the root folder.")

# Directly use the provided file paths

promedios_nd_negro = cargar_archivo_nd(ruta_objeto_negro, 'Negro')
promedios_nd_blanco = cargar_archivo_nd(ruta_objeto_blanco, 'Blanco')

# Initialize dictionaries to store average values for each band

 promedios_bandas_negro = {} # Initialize as an empty dictionary
promedios_bandas_blanco = {} # Initialize as an empty dictionary

for subcarpeta in subcarpetas:

carpeta_subcarpeta = [Link](carpeta_raiz, subcarpeta)
try: # Add a try-except block to handle potential errors
if 'negro' in [Link]():
df_promedio =
calcular_promedio_archivos_de_carpeta(carpeta_subcarpeta)
if df_promedio is not None: # Check if df_promedio is valid
promedios_bandas_negro = guardar_por_banda(df_promedio,
carpeta_subcarpeta, es_objeto_negro=True)
elif 'blanco' in [Link]():
df_promedio =
calcular_promedio_archivos_de_carpeta(carpeta_subcarpeta)
if df_promedio is not None: # Check if df_promedio is valid
promedios_bandas_blanco = guardar_por_banda(df_promedio,
carpeta_subcarpeta, es_objeto_negro=False)
except (ValueError, FileNotFoundError) as e:
print(f"Error processing subfolder {subcarpeta}: {e}") # Print error
messages for debugging

# Reformatting promedios_bandas_negro and promedios_bandas_blanco before saving

to Excel
bandas = ['Verde', 'Roja', 'Borde_Rojo', 'Infrarrojo_Cercano']
promedios_bandas_negro_reformatted = {f'Promedio_{banda}':
promedios_bandas_negro.get(banda) for banda in bandas}
promedios_bandas_blanco_reformatted = {f'Promedio_{banda}':
promedios_bandas_blanco.get(banda) for banda in bandas}

# Ensure promedios_bandas_negro and promedios_bandas_blanco are defined

if promedios_bandas_negro: # Check if not empty
promedios_bandas_negro_reformatted = {f'Promedio_{banda}':
promedios_bandas_negro.get(banda) for banda in bandas}
if promedios_bandas_blanco: # Check if not empty
promedios_bandas_blanco_reformatted = {f'Promedio_{banda}':
promedios_bandas_blanco.get(banda) for banda in bandas}

# Guardar promedios en Excel using reformatted dictionaries

guardar_promedios_en_excel(promedios_bandas_negro_reformatted,
promedios_bandas_blanco_reformatted, promedios_nd_negro, promedios_nd_blanco,
ruta_guardado)

return promedios_bandas_negro_reformatted, promedios_bandas_blanco_reformatted

# Return reformatted dictionaries
def main():
carpeta_principal = input("Introduce el nombre de la carpeta principal con los
archivos TRM: ")
# Get the full path for the ND files, including file names
ruta_objeto_negro = input("Introduce la ruta completa del archivo ND del objeto
negro (incluyendo nombre del archivo): ")
ruta_objeto_blanco = input("Introduce la ruta completa del archivo ND del
objeto blanco (incluyendo nombre del archivo): ")
ruta_guardado = carpeta_principal
 # Cargar archivos ND y calcular promedios
promedios_nd_negro = cargar_archivo_nd(ruta_objeto_negro, 'Negro') # Removed
the extra argument 'Objeto_Negro'
promedios_nd_blanco = cargar_archivo_nd(ruta_objeto_blanco, 'Blanco') #
Removed the extra argument 'Objeto_Blanco'

# Call procesar_subcarpetas with both arguments and assign the returned values
promedios_bandas_negro, promedios_bandas_blanco =
procesar_subcarpetas(carpeta_principal, ruta_guardado, ruta_objeto_negro,
ruta_objeto_blanco) # Pass file paths to procesar_subcarpetas and capture returned
values

# Access the values from the dictionaries

promedios_bandas_negro_values = list(promedios_bandas_negro.values())
promedios_bandas_blanco_values = list(promedios_bandas_blanco.values())

# Verificar los promedios que se están utilizando para la regresión

print("Promedios Bandas Negro:", promedios_bandas_negro)
print("Promedios Bandas Blanco:", promedios_bandas_blanco)
print("Promedios ND Negro:", promedios_nd_negro)
print("Promedios ND Blanco:", promedios_nd_blanco)

# Assign the calculated values from procesar_subcarpetas

# Access the values from the dictionaries
promedios_bandas_negro_values = list(promedios_bandas_negro.values())
promedios_bandas_blanco_values = list(promedios_bandas_blanco.values())

# Verificar los promedios que se están utilizando para la regresión

print("Promedios Bandas Negro:", promedios_bandas_negro)
print("Promedios Bandas Blanco:", promedios_bandas_blanco)
print("Promedios ND Negro:", promedios_nd_negro)
print("Promedios ND Blanco:", promedios_nd_blanco)

# Call the new function for regression

ruta_excel_promedios = [Link](carpeta_principal,
'promedios_totales_bandas.xlsx')
generar_graficas_regresion_conjunta(ruta_excel_promedios, carpeta_principal)

# Guardar los promedios en un archivo Excel

guardar_promedios_en_excel(
list(promedios_bandas_negro.values()), # Convertir en lista
list(promedios_bandas_blanco.values()), # Convertir en lista
list(promedios_nd_negro.values()), # Convertir en lista
list(promedios_nd_blanco.values()), # Convertir en lista
carpeta_principal
)
# Ejecutar el programa principal
if __name__ == "__main__":
main()