Mira este código, no quiero quee xista un límite definido de filas por Columna: import…
- User
Mira este código, no quiero quee xista un límite definido de filas por Columna: import sys import json import os import numpy as np from shapely.geometry import Polygon, Point
Configuración de Matplotlib
os.environ['MPLCONFIGDIR'] = '/app/matplotlib/'
Variables globales
Asumir que la latitud promedio que utilizamos es de 0 grados para obtener este valor
METERS_TO_DEGREES_LAT = 1 / 111320 # Conversión aproximada de metros a grados de latitud mesa_ancho, mesa_largo = 10 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT inversor_ancho, inversor_largo = 3 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT max_distance = 30 * METERS_TO_DEGREES_LAT min_distance = 10 * METERS_TO_DEGREES_LAT max_filas_por_columna = 10 espacio_columna = mesa_ancho + (1 * METERS_TO_DEGREES_LAT) espacio_fila = mesa_largo + (2 * METERS_TO_DEGREES_LAT) desviacion_lateral = 2 * METERS_TO_DEGREES_LAT
def generar_posiciones_columna(col_index, max_filas, inversor_pos, half_columnas): positions = [] for row in range(max_filas): base_x = inversor_pos[0] + col_index * espacio_columna pos_arriba = np.array([base_x, inversor_pos[1] + row * espacio_fila + mesa_largo]) pos_abajo = np.array([base_x, inversor_pos[1] - (row + 1) * espacio_fila])
# Calcula la distancia desde cada esquina de la mesa al inversor corners_arriba = [ [pos_arriba[0], pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1] + mesa_largo], [pos_arriba[0], pos_arriba[1] + mesa_largo] ] corners_abajo = [ [pos_abajo[0], pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1] + mesa_largo], [pos_abajo[0], pos_abajo[1] + mesa_largo] ] # Verifica si todas las esquinas de la mesa cumplen con la distancia mínima y máxima if all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_arriba): positions.append(pos_arriba) if all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_abajo): positions.append(pos_abajo) return positionsdef esta_dentro_del_poligono(punto, poligono): return poligono.contains(Point(punto))
def crear_inversor_feature(inversor_pos): x, y = inversor_pos inversor_coordenadas = [ [x - inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y - inversor_largo / 2] ] return { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [inversor_coordenadas] }, "properties": { "id": "Inversor", "style": { "fill": "#ff0000", "stroke": "#ff0000" } } }
def main(): if len(sys.argv) <= 1: sys.stdout.write("No se recibieron datos.\n") return
try: json_params = sys.argv[1] data = json.loads(json_params) if 'geojson' not in data: raise ValueError("El objeto JSON proporcionado no contiene la clave 'geojson'.") geojson = data['geojson'] if 'geometry' not in geojson: raise ValueError("El objeto GeoJSON no contiene la clave 'geometry'.") polygon_coords = geojson['geometry']['coordinates'][0] polygon = Polygon(polygon_coords) np.random.seed(42) num_mesas = 400 inversor_pos = np.array([polygon.centroid.x, polygon.centroid.y]) # Verificar si el inversor está demasiado cerca del borde del polígono if not polygon.contains(Point(inversor_pos).buffer(min_distance)): raise ValueError("El inversor está demasiado cerca del borde del polígono.") total_columnas = (num_mesas + max_filas_por_columna - 1) // max_filas_por_columna half_columnas = total_columnas // 2 all_positions = [] for col in range(-half_columnas, half_columnas + 1): column_positions = generar_posiciones_columna(col, max_filas_por_columna, inversor_pos, half_columnas) all_positions.extend(column_positions) mesas_pos = [pos for pos in all_positions if esta_dentro_del_poligono(pos, polygon)][:num_mesas] if len(mesas_pos) == 0: raise ValueError("No se generaron posiciones válidas para las mesas dentro del polígono.") features = [] for i, pos in enumerate(mesas_pos): x, y = pos coordinates = [ [x, y], [x + mesa_ancho, y], [x + mesa_ancho, y + mesa_largo], [x, y + mesa_largo], [x, y] ] feature = { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [coordinates] }, "properties": { "id": f"Mesa {i + 1}" } } features.append(feature) inversor_feature = crear_inversor_feature(inversor_pos) features.append(inversor_feature) geojson_output = { "type": "FeatureCollection", "features": features } sys.stdout.write(json.dumps(geojson_output, separators=(',', ':'))) except Exception as e: error_message = f"Error al procesar los datos: {e}." if 'data' in locals(): error_message += f" Datos recibidos: {json.dumps(data)}" sys.stdout.write(error_message + "\n")if name == "main": main()
- Assistant
Para eliminar el límite definido de filas por columna en tu código, simplemente debes modificar la lógica que maneja el número de filas máximas que se generan en cada columna. Actualmente, el código utiliza la variable
max_filas_por_columnapara limitar este valor. Puedes hacer los siguientes cambios para permitir un número dinámico de posiciones sin un límite específico:-
Eliminar el límite de filas por columna: En la función
main, al calculartotal_columnas, remueve la dependencia demax_filas_por_columna. -
Modificar la generación de posiciones: Ajusta la lógica dentro de la función
generar_posiciones_columnapara que trate de llenar las posiciones de mesas dentro del polígono sin un límite fijo por columna.
Aquí tienes las modificaciones que podrías hacer:
def generar_posiciones_columna(col_index, inversor_pos, half_columnas, polygon): positions = [] row = 0 while True: base_x = inversor_pos[0] + col_index * espacio_columna pos_arriba = np.array([base_x, inversor_pos[1] + row * espacio_fila + mesa_largo]) pos_abajo = np.array([base_x, inversor_pos[1] - (row + 1) * espacio_fila]) # Calcula la distancia desde cada esquina de la mesa al inversor corners_arriba = [ [pos_arriba[0], pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1] + mesa_largo], [pos_arriba[0], pos_arriba[1] + mesa_largo] ] corners_abajo = [ [pos_abajo[0], pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1] + mesa_largo], [pos_abajo[0], pos_abajo[1] + mesa_largo] ] # Verifica si todas las esquinas de la mesa cumplen con la distancia mínima y máxima valid_pos_arriba = all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_arriba) valid_pos_abajo = all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_abajo) # Adicionalmente verificar si está dentro del polígono if valid_pos_arriba and esta_dentro_del_poligono(pos_arriba, polygon): positions.append(pos_arriba) if valid_pos_abajo and esta_dentro_del_poligono(pos_abajo, polygon): positions.append(pos_abajo) # Si ambas posiciones no son válidas, no hay más espacio en la columna if not valid_pos_arriba and not valid_pos_abajo: break row += 1 return positions def main(): # ... (resto del código permanece igual) # total_columnas = (num_mesas + max_filas_por_columna - 1) // max_filas_por_columna # Cambiar para solo usar el inversor como centro y calcular desde ahí half_columnas = 10 # O cualquier otro número que quieras usar para límite inicial de columnas exploradas all_positions = [] for col in range(-half_columnas, half_columnas + 1): # Pasa al polígono a la función para verificar directamente dentro de ella column_positions = generar_posiciones_columna(col, inversor_pos, half_columnas, polygon) all_positions.extend(column_positions) # Sigue limitando el total de mesas a num_mesas mesas_pos = [pos for pos in all_positions][:num_mesas] # ... (resto del código permanece igual)En esta versión, la función
generar_posiciones_columnacontinúa generando posiciones mientras las condiciones de validez (distancia y pertenencia al polígono) se cumplan, eliminando así el límite estricto de filas para cada columna. Asegúrate de ajustarhalf_columnaspara controlar cuántas columnas alrededor del inversor deseas explorar. Esto controlará indirectamente el tamaño máximo al que puedes expandir las posiciones. -
- User
Envia todo el código corregido
- Assistant
Aquí tienes el código completo corregido, donde se elimina el límite fijo de filas por columna y permite que las posiciones se generen dinámicamente dentro de las restricciones dadas:
import sys import json import os import numpy as np from shapely.geometry import Polygon, Point # Configuración de Matplotlib os.environ['MPLCONFIGDIR'] = '/app/matplotlib/' # Variables globales # Asumir que la latitud promedio que utilizamos es de 0 grados para obtener este valor METERS_TO_DEGREES_LAT = 1 / 111320 # Conversión aproximada de metros a grados de latitud mesa_ancho, mesa_largo = 10 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT inversor_ancho, inversor_largo = 3 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT max_distance = 30 * METERS_TO_DEGREES_LAT min_distance = 10 * METERS_TO_DEGREES_LAT espacio_columna = mesa_ancho + (1 * METERS_TO_DEGREES_LAT) espacio_fila = mesa_largo + (2 * METERS_TO_DEGREES_LAT) desviacion_lateral = 2 * METERS_TO_DEGREES_LAT def generar_posiciones_columna(col_index, inversor_pos, polygon): positions = [] row = 0 while True: base_x = inversor_pos[0] + col_index * espacio_columna pos_arriba = np.array([base_x, inversor_pos[1] + row * espacio_fila + mesa_largo]) pos_abajo = np.array([base_x, inversor_pos[1] - (row + 1) * espacio_fila]) # Calcula la distancia desde cada esquina de la mesa al inversor corners_arriba = [ [pos_arriba[0], pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1]], [pos_arriba[0] + mesa_ancho, pos_arriba[1] + mesa_largo], [pos_arriba[0], pos_arriba[1] + mesa_largo] ] corners_abajo = [ [pos_abajo[0], pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1]], [pos_abajo[0] + mesa_ancho, pos_abajo[1] + mesa_largo], [pos_abajo[0], pos_abajo[1] + mesa_largo] ] # Verifica si todas las esquinas de la mesa cumplen con la distancia mínima y máxima valid_pos_arriba = all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_arriba) and esta_dentro_del_poligono(pos_arriba, polygon) valid_pos_abajo = all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in corners_abajo) and esta_dentro_del_poligono(pos_abajo, polygon) # Añadir si es válido y sigue dentro del polígono if valid_pos_arriba: positions.append(pos_arriba) if valid_pos_abajo: positions.append(pos_abajo) # Termina si ya no hay lugar válido en la dirección actual if not valid_pos_arriba and not valid_pos_abajo: break row += 1 return positions def esta_dentro_del_poligono(punto, poligono): return poligono.contains(Point(punto)) def crear_inversor_feature(inversor_pos): x, y = inversor_pos inversor_coordenadas = [ [x - inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y - inversor_largo / 2] ] return { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [inversor_coordenadas] }, "properties": { "id": "Inversor", "style": { "fill": "#ff0000", "stroke": "#ff0000" } } } def main(): if len(sys.argv) <= 1: sys.stdout.write("No se recibieron datos.\n") return try: json_params = sys.argv[1] data = json.loads(json_params) if 'geojson' not in data: raise ValueError("El objeto JSON proporcionado no contiene la clave 'geojson'.") geojson = data['geojson'] if 'geometry' not in geojson: raise ValueError("El objeto GeoJSON no contiene la clave 'geometry'.") polygon_coords = geojson['geometry']['coordinates'][0] polygon = Polygon(polygon_coords) np.random.seed(42) num_mesas = 400 inversor_pos = np.array([polygon.centroid.x, polygon.centroid.y]) # Verificar si el inversor está demasiado cerca del borde del polígono if not polygon.contains(Point(inversor_pos).buffer(min_distance)): raise ValueError("El inversor está demasiado cerca del borde del polígono.") half_columnas = 10 # Usa un valor inicial para cuántas columnas buscar a cada lado del inversor all_positions = [] for col in range(-half_columnas, half_columnas + 1): column_positions = generar_posiciones_columna(col, inversor_pos, polygon) all_positions.extend(column_positions) mesas_pos = [pos for pos in all_positions][:num_mesas] if len(mesas_pos) == 0: raise ValueError("No se generaron posiciones válidas para las mesas dentro del polígono.") features = [] for i, pos in enumerate(mesas_pos): x, y = pos coordinates = [ [x, y], [x + mesa_ancho, y], [x + mesa_ancho, y + mesa_largo], [x, y + mesa_largo], [x, y] ] feature = { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [coordinates] }, "properties": { "id": f"Mesa {i + 1}" } } features.append(feature) inversor_feature = crear_inversor_feature(inversor_pos) features.append(inversor_feature) geojson_output = { "type": "FeatureCollection", "features": features } sys.stdout.write(json.dumps(geojson_output, separators=(',', ':'))) except Exception as e: error_message = f"Error al procesar los datos: {e}." if 'data' in locals(): error_message += f" Datos recibidos: {json.dumps(data)}" sys.stdout.write(error_message + "\n") if __name__ == "__main__": main()En este código,
generar_posiciones_columnasigue llenando posiciones hasta que no se encuentren más válidas en cada columna, tomando en cuenta tanto la distancia a las posiciones del inversor como la ubicación dentro del polígono. La cantidad de columnas a explorar puede ser modificada cambiando el valor dehalf_columnas. - User
Noooooo, no se están distribuyendo bien
- Assistant
Lamento que la solución anterior no funcionara como esperabas. Vamos a revisar cómo se posicionan las mesas y asegurarnos de que se distribuyan correctamente en columnas, sin un límite fijo para las filas.
El problema podría ser que no estamos haciendo un buen uso de las condiciones para validar las posiciones de las mesas en función de las restricciones espaciales y del polígono. Aquí está el código modificado con enfoque especial en corregir la distribución:
import sys import json import os import numpy as np from shapely.geometry import Polygon, Point # Configuración de Matplotlib os.environ['MPLCONFIGDIR'] = '/app/matplotlib/' # Variables globales # Asumir que la latitud promedio que utilizamos es de 0 grados para obtener este valor METERS_TO_DEGREES_LAT = 1 / 111320 # Conversión aproximada de metros a grados de latitud mesa_ancho, mesa_largo = 10 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT inversor_ancho, inversor_largo = 3 * METERS_TO_DEGREES_LAT, 2 * METERS_TO_DEGREES_LAT max_distance = 30 * METERS_TO_DEGREES_LAT min_distance = 10 * METERS_TO_DEGREES_LAT espacio_columna = mesa_ancho + (1 * METERS_TO_DEGREES_LAT) espacio_fila = mesa_largo + (2 * METERS_TO_DEGREES_LAT) desviacion_lateral = 2 * METERS_TO_DEGREES_LAT def generar_posiciones_columna(col_index, inversor_pos, polygon): positions = [] row = 0 while True: base_x = inversor_pos[0] + col_index * espacio_columna pos_arriba = np.array([base_x, inversor_pos[1] + row * espacio_fila + mesa_largo]) pos_abajo = np.array([base_x, inversor_pos[1] - (row + 1) * espacio_fila]) # Verificación de validez if validar_posicion(pos_arriba, inversor_pos, polygon): positions.append(pos_arriba) if validar_posicion(pos_abajo, inversor_pos, polygon): positions.append(pos_abajo) # Salir si no encontramos posiciones válidas en ambas direcciones (ya exploradas) if not validar_posicion(pos_arriba, inversor_pos, polygon) and not validar_posicion(pos_abajo, inversor_pos, polygon): break row += 1 return positions def validar_posicion(pos, inversor_pos, polygon): # Comprobar la distancia y si está dentro del polígono distancia_valida = all(min_distance <= np.linalg.norm(np.array(corner) - inversor_pos) <= max_distance for corner in [ pos, [pos[0] + mesa_ancho, pos[1]], [pos[0] + mesa_ancho, pos[1] + mesa_largo], [pos[0], pos[1] + mesa_largo] ]) return distancia_valida and esta_dentro_del_poligono(pos, polygon) def esta_dentro_del_poligono(punto, poligono): mesa_rect = Polygon([ punto, [punto[0] + mesa_ancho, punto[1]], [punto[0] + mesa_ancho, punto[1] + mesa_largo], [punto[0], punto[1] + mesa_largo] ]) return poligono.contains(mesa_rect) def crear_inversor_feature(inversor_pos): x, y = inversor_pos inversor_coordenadas = [ [x - inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y - inversor_largo / 2], [x + inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y + inversor_largo / 2], [x - inversor_ancho / 2, y - inversor_largo / 2] ] return { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [inversor_coordenadas] }, "properties": { "id": "Inversor", "style": { "fill": "#ff0000", "stroke": "#ff0000" } } } def main(): if len(sys.argv) <= 1: sys.stdout.write("No se recibieron datos.\n") return try: json_params = sys.argv[1] data = json.loads(json_params) if 'geojson' not in data: raise ValueError("El objeto JSON proporcionado no contiene la clave 'geojson'.") geojson = data['geojson'] if 'geometry' not in geojson: raise ValueError("El objeto GeoJSON no contiene la clave 'geometry'.") polygon_coords = geojson['geometry']['coordinates'][0] polygon = Polygon(polygon_coords) np.random.seed(42) num_mesas = 400 inversor_pos = np.array([polygon.centroid.x, polygon.centroid.y]) # Verificar si el inversor está demasiado cerca del borde del polígono if not polygon.contains(Point(inversor_pos).buffer(min_distance)): raise ValueError("El inversor está demasiado cerca del borde del polígono.") half_columnas = 10 all_positions = [] for col in range(-half_columnas, half_columnas + 1): column_positions = generar_posiciones_columna(col, inversor_pos, polygon) all_positions.extend(column_positions) mesas_pos = [pos for pos in all_positions][:num_mesas] if len(mesas_pos) == 0: raise ValueError("No se generaron posiciones válidas para las mesas dentro del polígono.") features = [] for i, pos in enumerate(mesas_pos): x, y = pos coordinates = [ [x, y], [x + mesa_ancho, y], [x + mesa_ancho, y + mesa_largo], [x, y + mesa_largo], [x, y] ] feature = { "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [coordinates] }, "properties": { "id": f"Mesa {i + 1}" } } features.append(feature) inversor_feature = crear_inversor_feature(inversor_pos) features.append(inversor_feature) geojson_output = { "type": "FeatureCollection", "features": features } sys.stdout.write(json.dumps(geojson_output, separators=(',', ':'))) except Exception as e: error_message = f"Error al procesar los datos: {e}." if 'data' in locals(): error_message += f" Datos recibidos: {json.dumps(data)}" sys.stdout.write(error_message + "\n") if __name__ == "__main__": main()En esta versión, se mantiene la validación al nivel de las posiciones y se asegura que tanto la distancia como la ubicación dentro del polígono sean evaluadas correctamente antes de aceptar una posición para una mesa. Asegúrate de verificar el polígono de entrada para asegurarte de que se puedan crear las columnas y las filas correctamente.