Cómo Automatizar Planos Estructurales con ChatGPT, Gemini, Claude y Python

El dibujo y detallado de planos estructurales en programas de diseño asistido por computadora (CAD) es uno de los procesos que mayor consumo de horas-hombre representa en los proyectos de ingeniería civil y edificación. Con la masificación de los modelos fundacionales de inteligencia artificial como ChatGPT (OpenAI), Claude (Anthropic) y Gemini (Google), muchos profesionales intentaron inicialmente solicitar «dibujos de planos» directamente a la IA, encontrándose con imágenes artísticas incoherentes, cotas ilegibles y falta absoluta de rigor normativo.

La metodología correcta que utilizan los equipos de ingeniería de alto rendimiento no es pedir imágenes, sino utilizar la inteligencia artificial como un motor de razonamiento algorítmico que produce scripts paramétricos en Python. Al combinar el entendimiento conceptual de los LLMs con bibliotecas como ezdxf, es posible transformar descripciones de cálculo en planos vectoriales puros en formato DXF con precisión milimétrica, capas normalizadas y tablas de despiece de acero listas para producción.

Comparativa de Modelos de IA para Ingeniería Estructural

Meta-Prompt de Ingeniería: Cómo Obtener Código CAD Confiable

Para evitar que el modelo invente librerías o produzca código inservible, utiliza la siguiente estructura de System Prompt:

Actúa como un Ingeniero Estructural Senior experto en Python y automatización CAD.
Tu objetivo es escribir un script en Python utilizando ÚNICAMENTE la librería 'ezdxf'.
REGLAS OBLIGATORIAS:
1. Todas las medidas deben estar en milímetros (mm).
2. Crea capas normalizadas: 'CONTORNO' (blanco), 'ACERO_LONG' (rojo), 'ESTRIBOS' (cian), 'COTAS' (verde).
3. Utiliza entidades nativas 'add_lwpolyline' para contornos y 'add_line' para armaduras.
4. Aplica criterios de confinamiento sismorresistente según ACI 318 (zona confina a 2h de apoyos).
5. Devuelve solo código Python ejecutable sin explicaciones intermedias.

Script Python Completo: Generador de Cuadro de Columnas a DXF

A continuación tienes el script generado y verificado que dibuja una sección transversal de columna de concreto armado ($40 \times 40\text{ cm}$) con estribo perimetral cerrado, trabas suplementarias y barras longitudinales perfectamente acotadas.

"""
Generador Parametrico de Secciones Estructurales de Columnas en DXF.
Disenado para automatizacion de planos con IA y Python.
Requiere: pip install ezdxf
"""

import math
import ezdxf
from ezdxf import colors


def inicializar_capas_dxf(doc):
    """Crea y asigna capas normalizadas para planos estructurales."""
    capas = [
        ("COLUMNA_CONCRETO", colors.WHITE, "CONTINUOUS"),
        ("ESTRIBO_CONFINAMIENTO", colors.CYAN, "CONTINUOUS"),
        ("ACERO_LONGITUDINAL", colors.RED, "CONTINUOUS"),
        ("COTAS_DIMENSIONES", colors.GREEN, "CONTINUOUS"),
        ("TEXTOS_ROTULOS", colors.YELLOW, "CONTINUOUS"),
    ]
    for nombre, color, linea in capas:
        if nombre not in doc.layers:
            doc.layers.add(name=nombre, color=color, linetype=linea)


def generar_seccion_columna(
    archivo_salida="seccion_columna_ia.dxf",
    lado_x_mm=400.0,
    lado_y_mm=400.0,
    recubrimiento_mm=40.0,
    diametro_long_mm=19.0,
    diametro_estribo_mm=9.5,
    num_barras_x=3,
    num_barras_y=3,
):
    """Dibuja la seccion transversal completa de una columna de concreto armado."""
    doc = ezdxf.new(dxfversion="R2010")
    msp = doc.modelspace()
    inicializar_capas_dxf(doc)

    x0 = 0.0
    y0 = 0.0

    # 1. Contorno exterior de concreto
    contorno = [
        (x0, y0),
        (x0 + lado_x_mm, y0),
        (x0 + lado_x_mm, y0 + lado_y_mm),
        (x0, y0 + lado_y_mm),
    ]
    msp.add_lwpolyline(
        contorno,
        close=True,
        dxfattribs={"layer": "COLUMNA_CONCRETO", "lineweight": 40},
    )

    # 2. Estribo perimetral cerrado
    x_est_min = x0 + recubrimiento_mm
    y_est_min = y0 + recubrimiento_mm
    x_est_max = x0 + lado_x_mm - recubrimiento_mm
    y_est_max = y0 + lado_y_mm - recubrimiento_mm

    estribo_coords = [
        (x_est_min, y_est_min),
        (x_est_max, y_est_min),
        (x_est_max, y_est_max),
        (x_est_min, y_est_max),
    ]
    msp.add_lwpolyline(
        estribo_coords,
        close=True,
        dxfattribs={"layer": "ESTRIBO_CONFINAMIENTO", "lineweight": 25},
    )

    # 3. Barras longitudinales (distribuidas en el perimetro)
    radio_barra = diametro_long_mm / 2.0
    espacio_x = (x_est_max - x_est_min) / (num_barras_x - 1)
    espacio_y = (y_est_max - y_est_min) / (num_barras_y - 1)

    puntos_barras = set()
    # Cara inferior y superior
    for i in range(num_barras_x):
        px = x_est_min + (i * espacio_x)
        puntos_barras.add((px, y_est_min))
        puntos_barras.add((px, y_est_max))
    # Caras laterales
    for j in range(num_barras_y):
        py = y_est_min + (j * espacio_y)
        puntos_barras.add((x_est_min, py))
        puntos_barras.add((x_est_max, py))

    for bx, by in puntos_barras:
        msp.add_circle(
            (bx, by),
            radius=radio_barra,
            dxfattribs={"layer": "ACERO_LONGITUDINAL"},
        )

    # 4. Rotulo de identificacion
    total_barras = len(puntos_barras)
    texto = f"COLUMNA C-1 ({int(lado_x_mm/10)}x{int(lado_y_mm/10)} cm) - {total_barras} Barras #6"
    msp.add_text(
        texto,
        dxfattribs={
            "layer": "TEXTOS_ROTULOS",
            "height": 25.0,
            "insert": (x0, y0 - 50.0),
        },
    )

    doc.saveas(archivo_salida)
    print(f"[OK] Plano DXF de columna generado exitosamente: {archivo_salida}")
    return archivo_salida


if __name__ == "__main__":
    generar_seccion_columna()