Resumen
Este paper presenta una metodología para optimizar el uso de tela en procesos de tendido, utilizando patrones de corte basados en archivos DXF. Se exploran técnicas de optimización geométrica con la librería Shapely en Python, extrayendo figuras geométricas y sus coordenadas óptimas. Los resultados se envían al frontend en formato JSON y se visualizan mediante SVG en un entorno Vue.js. Este enfoque reduce conversiones innecesarias de formatos y proporciona una representación clara y escalable de los patrones en el navegador. El objetivo es maximizar el uso de tela y mejorar la eficiencia en la disposición de los patrones.
1. Introducción
En la industria textil, la optimización del uso de tela en tendidos es crucial para reducir el desperdicio y mejorar la eficiencia de producción. Los patrones de corte, frecuentemente representados en archivos DXF, requieren técnicas de acomodación dentro de áreas rectangulares que representan la tela disponible. Este paper detalla un enfoque basado en algoritmos geométricos utilizando Shapely en Python para calcular las mejores posiciones de los patrones y cómo estas posiciones se visualizan en un entorno frontend utilizando Vue.js y SVG.
2. Ingeniería y Metodología
El sistema se basa en un proceso de dos partes:
- Backend: Procesamiento de archivos DXF, cálculo geométrico y optimización de patrones utilizando Python y Shapely.
- Frontend: Visualización de los resultados con Vue.js y SVG en un entorno web.
2.1 Lectura y Conversión de DXF
Para procesar los archivos DXF y extraer las figuras geométricas, utilizamos la librería ezdxf para convertir las entidades en coordenadas que Shapely pueda manipular.
pythonCopiar códigoimport ezdxf
from shapely.geometry import Point, box
# Cargar el archivo DXF
doc = ezdxf.readfile("tendido.dxf")
msp = doc.modelspace()
# Extraer las entidades del DXF
figures = []
for entity in msp:
if entity.dxftype() == 'CIRCLE':
circle = Point(entity.dxf.center).buffer(entity.dxf.radius)
figures.append(circle)
elif entity.dxftype() == 'LWPOLYLINE':
points = [(p[0], p[1]) for p in entity.get_points()]
poly = box(*points) # Polígono aproximado como un rectángulo
figures.append(poly)
2.2 Optimización del Acomodo de Patrones
Con Shapely, calculamos la disposición óptima de los patrones dentro de un rectángulo que representa el ancho y largo del tendido de tela. Utilizamos un algoritmo de colocación basado en coordenadas y filas.
pythonCopiar códigofrom shapely.affinity import translate
from shapely.geometry import box
def can_place_figure(figures, new_figure, confinement_rect):
if not confinement_rect.contains(new_figure):
return False
for figure in figures:
if new_figure.intersects(figure):
return False
return True
def optimize_container_length(figures, max_height, max_width, time_limit):
start_time = time.time()
step = 10
for width in range(200, max_width + step, step):
if time.time() - start_time > time_limit:
return None, None
confinement_rect = box(0, 0, width, max_height)
placed_figures = []
x_offset, y_offset, row_max_height = 0, 0, 0
for figure in figures:
figure_width, figure_height = figure.bounds[2] - figure.bounds[0], figure.bounds[3] - figure.bounds[1]
if x_offset + figure_width > width:
x_offset = 0
y_offset += row_max_height
row_max_height = 0
new_figure = translate(figure, xoff=x_offset, yoff=y_offset)
if can_place_figure(placed_figures, new_figure, confinement_rect):
placed_figures.append(new_figure)
x_offset += figure_width
row_max_height = max(row_max_height, figure_height)
if len(placed_figures) == len(figures):
return width, placed_figures
return None, None
Este algoritmo asegura que las figuras geométricas no se encimen ni se salgan del área de confinamiento, utilizando un proceso recursivo limitado por tiempo.
2.3 Exportación a JSON
Una vez calculadas las posiciones óptimas, exportamos la información en formato JSON para ser consumida por el frontend.
pythonCopiar códigoimport json
def export_to_json(placed_figures):
figure_list = []
for figure in placed_figures:
if figure.geom_type == 'Polygon':
figure_list.append({
"type": "rect",
"x": figure.bounds[0],
"y": figure.bounds[1],
"width": figure.bounds[2] - figure.bounds[0],
"height": figure.bounds[3] - figure.bounds[1]
})
return json.dumps({"figures": figure_list}, indent=4)
3. Visualización en el Frontend
Para la visualización en Vue.js, utilizamos SVG por su capacidad para representar gráficos vectoriales y manipular las coordenadas directamente en el DOM. Este enfoque evita la necesidad de conversiones de formato adicionales y permite la interactividad directa.
3.1 Componente Vue con SVG
vueCopiar código<template>
<div>
<svg :width="containerWidth" :height="containerHeight">
<rect
v-for="(figure, index) in figures"
v-if="figure.type === 'rect'"
:key="'rect-' + index"
:x="figure.x"
:y="figure.y"
:width="figure.width"
:height="figure.height"
fill="transparent"
stroke="blue"
stroke-width="2"
/>
</svg>
</div>
</template>
<script>
export default {
data() {
return {
containerWidth: 1000,
containerHeight: 160,
figures: []
};
},
mounted() {
this.figures = [
{ type: 'rect', x: 10, y: 20, width: 100, height: 50 }
];
}
};
</script>
4. Resultados
El sistema permite una optimización significativa del uso de tela al calcular las posiciones de los patrones dentro de un área limitada. Las figuras se generan a partir de archivos DXF y se optimizan utilizando algoritmos geométricos. El enfoque basado en JSON y SVG asegura una visualización escalable y sin pérdida de calidad en el navegador, haciendo que el proceso de optimización y visualización sea eficiente tanto para el backend como para el frontend.
5. Conclusiones
El enfoque presentado es eficiente para optimizar el uso de tela en la industria textil, utilizando geometría computacional para acomodar patrones de corte y visualizarlos de manera interactiva en un frontend basado en Vue.js. La combinación de Shapely para el cálculo geométrico y SVG para la visualización crea un flujo de trabajo eficiente y directo, reduciendo conversiones de formato y mejorando la interoperabilidad entre backend y frontend.
6. Futuro
Las próximas iteraciones del sistema podrían incluir mejoras en la lógica de acomodo, como algoritmos de optimización más avanzados (bin packing), y añadir interactividad avanzada en el frontend para permitir a los usuarios ajustar manualmente la disposición de los patrones en tiempo real.