Estructura inicial del proyecto

Contrato entre motor y aplicación en motor/api.py, motor simulado con CUBE01, pruebas del contrato, prototipo de la prueba técnica, documentación de trabajo y plantillas de Gitea.
2026-10-22 18:53:05 +02:00 · 2026-10-22 18:53:05 +02:00 · 4503df96bd
commit 4503df96bd
25 changed files with 21953 additions and 0 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,10 @@
 * text=auto eol=lf
 # Planos y modelos: Git no debe tocar sus finales de línea ni mostrarlos como diff
 *.dxf binary
 *.dwg binary
 *.pdf binary
 *.step binary
 *.stp binary
 *.stl binary
 *.png binary
--- a/.gitea/ISSUE_TEMPLATE/error.md
+++ b/.gitea/ISSUE_TEMPLATE/error.md
@ -0,0 +1,17 @@
 ---
 name: "Error"
 about: "Algo no funciona como debería"
 ---
 ## Qué pasa
 ## Qué debería pasar
 ## Cómo reproducirlo
 - Plano usado (adjuntar o ruta en `pruebas/catalogo/`):
 - Pasos:
 ## Gravedad
 bloqueante / alta / media / baja
--- a/.gitea/ISSUE_TEMPLATE/tarea.md
+++ b/.gitea/ISSUE_TEMPLATE/tarea.md
@ -0,0 +1,14 @@
 ---
 name: "Tarea"
 about: "Trabajo planificado del backlog"
 ---
 ## Objetivo
 ## Criterio de terminado
 - [ ]
 ## Área
 motor / app / pruebas / docs
--- a/.gitea/pull_request_template.md
+++ b/.gitea/pull_request_template.md
@ -0,0 +1,15 @@
 ## Qué cambia
 ## Cómo se ha probado
 - [ ] `uv run pytest` pasa
 - [ ] Probado a mano (explicar):
 ## Issue
 Closes #
 ## ¿Cambia el contrato `motor/api.py`?
 - [ ] No
 - [ ] Sí, acordado y anotado en `docs/decisiones.md`
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,21 @@
 # Python
 __pycache__/
 *.py[cod]
 .venv/
 .pytest_cache/
 # Empaquetado
 build/
 dist/
 *.spec
 # Resultados generados al probar (el catálogo sí se versiona)
 salidas/
 *_informe.md
 *_3d.png
 # Sistema y editores
 .DS_Store
 Thumbs.db
 .vscode/
 .idea/
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -0,0 +1,45 @@
 # Cómo trabajamos
 ## Ramas
 - `main` siempre funciona: nadie sube directamente a ella. Todo entra mediante *pull request* revisado por la otra persona.
 - Una rama por tarea, creada desde `main` actualizada, con el prefijo del área:
  - `motor/...`: procesado (p. ej. `motor/lectura-dwg`)
  - `app/...`: interfaz y visor (p. ej. `app/visor-ejes`)
  - `pruebas/...`, `docs/...`
 - Ramas cortas: mejor varios PR pequeños que uno enorme. Antes de abrir el PR, actualizar la rama con `main`.
 ```bash
 git switch main
 git pull
 git switch -c app/visor-ejes
 # ... trabajo y commits ...
 git push -u origin app/visor-ejes
 ```
 ## Commits
 En español, en imperativo y diciendo qué cambia: `Añade lectura de capas ocultas`, `Corrige escala en planos sin unidades`. Un commit por cambio con sentido propio.
 ## Issues y tablero
 - Cada tarea es un *issue* con etiqueta de área (`motor`, `app`, `pruebas`, `docs`) y asignado a quien la hace.
 - El tablero del proyecto en Gitea tiene las columnas **Pendiente · En curso · En revisión · Hecho**.
 - Los errores se registran como *issue* con la plantilla de error: son evidencia para el informe de calidad.
 ## Pull requests
 - La descripción dice qué cambia, cómo se ha probado y qué *issue* cierra (`Closes #12`).
 - `uv run pytest` debe pasar antes de pedir revisión.
 - La otra persona revisa y aprueba. La revisión cruzada es obligatoria: los dos tenemos que entender todo el código para la defensa.
 ## Contrato motor/aplicación
 `motor/api.py` es lo único que comparten las dos partes. Cualquier cambio en él se acuerda antes, se anota en `docs/decisiones.md` y va en un PR propio.
 ## Documentación continua
 - **Decisiones** (`docs/decisiones.md`): cada decisión de diseño o de alcance, con motivo.
 - **Bitácora** (`docs/bitacora.md`): qué ha hecho cada uno cada semana.
 - **Actas** (`docs/actas/`): una por reunión semanal.
 - **Uso de IA** (`docs/uso-ia.md`): cada uso relevante de herramientas de IA.
--- a/21
+++ b/21
@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2026 Equipo Plano3D
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/README.md
+++ b/README.md
@ -0,0 +1,33 @@
 # Plano3D
 Aplicación de escritorio que reconstruye automáticamente una pieza mecánica 3D (STEP/STL) a partir de su plano técnico 2D con alzado, planta y perfil (DXF, DWG o PDF vectorial), y verifica el plano: escala, cotas, coherencia entre vistas y ambigüedades.
 Proyecto intermodular de 2.º DAM, IES La Mar.
 ## Estructura
 | Carpeta | Contenido | Responsable |
 | --- | --- | --- |
 | `motor/` | Procesado: lectura del plano, vistas, reconstrucción, verificación, exportación | Motor |
 | `motor/api.py` | **Contrato** entre motor y aplicación: lo único que la aplicación importa | Los dos |
 | `app/` | Aplicación: interfaz Qt, visor 3D, historial, instalador | Aplicación |
 | `pruebas/` | Pruebas automáticas (`pytest`) y catálogo de piezas con su resultado esperado | Los dos |
 | `prototipo/` | Prueba técnica inicial (no se modifica; solo de referencia) | Los dos |
 | `docs/` | Guía técnica, registro de decisiones, bitácora, actas y declaración de uso de IA | Los dos |
 ## Puesta en marcha
 Requisitos: [uv](https://docs.astral.sh/uv/) y Git. CadQuery necesita Python 3.12 o 3.13; uv lo descarga solo.
 ```bash
 uv sync
 uv run pytest
 ```
 ## Formas de trabajo
 Ver [CONTRIBUTING.md](CONTRIBUTING.md): ramas, *pull requests*, revisiones e *issues*.
 ## Licencia
 MIT. Ver [LICENSE](LICENSE).
--- a/app/init.py
+++ b/app/init.py
@ -0,0 +1,4 @@
 """Aplicación de escritorio de Plano3D: interfaz (PySide6), visor 3D (VTK), historial e instalador.
 Solo usa el motor a través de motor.api (procesar, exportar y las clases del contrato).
 """
--- a/docs/actas/plantilla.md
+++ b/docs/actas/plantilla.md
@ -0,0 +1,25 @@
 # Acta de reunión AAAA-MM-DD
 - **Asistentes:**
 - **Modera / toma notas:** (rotatorio)
 - **Duración:**
 ## Revisión de la semana anterior
 | Tarea (issue) | Responsable | Estado |
 | --- | --- | --- |
 | | | |
 ## Temas tratados
 -
 ## Acuerdos
 -
 ## Tareas para la próxima semana
 | Tarea | Responsable | Issue |
 | --- | --- | --- |
 | | | |
--- a/docs/bitacora.md
+++ b/docs/bitacora.md
@ -0,0 +1,17 @@
 # Bitácora
 Una entrada por semana. Cada persona escribe lo suyo.
 ## Semana del AAAA-MM-DD
 ### Joel
 - Hecho:
 - Problemas:
 - Próxima semana:
 - Horas (clase / autónomas):
 ### (compañera)
 - Hecho:
 - Problemas:
 - Próxima semana:
 - Horas (clase / autónomas):
--- a/docs/decisiones.md
+++ b/docs/decisiones.md
@ -0,0 +1,15 @@
 # Registro de decisiones
 Cada decisión de alcance o de diseño, con su motivo. La más reciente, arriba.
 | Fecha | Decisión | Motivo |
 | --- | --- | --- |
 | 2026-10-22 | Reparto: Joel, aplicación (interfaz y visor 3D); compañera, motor de procesado. Contrato común en `motor/api.py` | Partes separables que pueden avanzar en paralelo con un motor simulado |
 | 2026-10-22 | Repositorio en la plataforma Gitea del instituto, con ramas por tarea y PR revisados | Requisito del módulo; trazabilidad de la contribución individual |
 | 2026-10-14 | Hitos H0 (fin de SA2) y H1 (fin de SA3), con plan B de piezas planas | Gestionar el riesgo técnico de la reconstrucción |
 | 2026-10-14 | Aplicación de escritorio, no web | Cálculo pesado con OpenCASCADE; privacidad de los planos; sin servidor ni costes |
 | 2026-10-14 | Alcance por prioridades; roscas como agujero + nota; revolución como importante | Equilibrio entre ambición y las horas del módulo |
 | 2026-10-14 | Lo no soportado se detecta y se avisa, nunca se reconstruye mal en silencio | Fiabilidad: una pieza errónea sin aviso es peor que ninguna |
 | 2026-10-14 | Reconstrucción automática desde 3 vistas, con verificación del plano | Es lo que Fusion 360 no hace; la versión "DXF + espesor" no aportaba valor |
 | 2026-10-14 | Prueba técnica con CUBE01.dxf: reconstrucción correcta y detección de proyección mixta | Comprobar la viabilidad antes de comprometer el alcance |
 | 2026-10-08 | Piezas mecánicas (no arquitectura); entradas DXF, DWG y PDF | Propuesta inicial del equipo |
--- a/docs/guia-tecnica.md
+++ b/docs/guia-tecnica.md
@ -0,0 +1,37 @@
 # Guía técnica
 Resumen de las decisiones técnicas vigentes y de las reglas del código. El detalle y la fecha de cada decisión están en [decisiones.md](decisiones.md).
 ## Producto
 Aplicación de escritorio que reconstruye piezas mecánicas 3D a partir de planos de tres vistas y verifica el plano. Todo se procesa en el equipo del usuario: no hay servidor ni cuentas.
 ## Tecnologías
 | Tecnología | Uso |
 | --- | --- |
 | Python 3.12 | Todo el proyecto |
 | CadQuery (OpenCASCADE) | Sólidos 3D y exportación STEP/STL |
 | ezdxf | Lectura de DXF |
 | shapely | Geometría 2D de las vistas |
 | OR-Tools CP-SAT | Búsqueda de la pieza que reproduce el plano |
 | PySide6 y VTK | Interfaz y visor 3D |
 | SQLite | Historial local de conversiones |
 | PyInstaller | Instalador |
 | pytest | Pruebas automáticas |
 ## Alcance
 - Entradas: DXF (imprescindible), DWG mediante conversor externo, PDF vectorial (importante).
 - Geometría imprescindible: tres vistas, caras planas, chaflanes, agujeros pasantes y roscas (agujero más nota).
 - Geometría importante: agujeros ciegos, avellanados y cajeados; piezas de revolución.
 - Sistemas de proyección europeo (ISO-E) y americano (ISO-A); se avisa si un plano los mezcla.
 - Lo que no se soporta se detecta y se avisa. Nunca se entrega una pieza que no reproduce el plano sin advertirlo.
 ## Reglas del código
 - `motor/api.py` es el contrato entre motor y aplicación. La aplicación solo importa desde ahí, y cualquier cambio se acuerda entre los dos.
 - `motor/simulado.py` devuelve la pieza CUBE01 mientras el motor real no esté terminado.
 - `prototipo/reconstruir.py` es la prueba técnica original. Se conserva como referencia y no se modifica.
 - Cada pieza del catálogo tiene su carpeta en `pruebas/catalogo/` con `plano.dxf`, `esperado.step` e `info.md`.
 - Ramas, commits y revisiones según [CONTRIBUTING.md](../CONTRIBUTING.md).
--- a/docs/uso-ia.md
+++ b/docs/uso-ia.md
@ -0,0 +1,10 @@
 # Declaración de uso de herramientas de IA
 Registro de los usos relevantes de IA en el proyecto, para la declaración de la memoria final.
 | Fecha | Herramienta | Quién | Para qué | Cómo se revisó |
 | --- | --- | --- | --- | --- |
 | 2026-10-08 | Claude (Claude Code) | Joel | Análisis de viabilidad de la idea y primer anteproyecto | Discutido y corregido en equipo |
 | 2026-10-14 | Claude (Claude Code) | Joel | Prototipo de reconstrucción (`prototipo/reconstruir.py`) a partir de CUBE01.dxf | Resultado abierto y comprobado en Fusion 360 |
 | 2026-10-14 | Claude (Claude Code) | Joel | Revisión de decisiones técnicas y redacción de la propuesta | Revisado por el equipo antes de entregarla |
 | 2026-10-22 | Claude (Claude Code) | Joel | Estructura del repositorio, contrato `motor/api.py`, motor simulado y plantillas | Revisado por el equipo |
--- a/motor/init.py
+++ b/motor/init.py
@ -0,0 +1,4 @@
 """Motor de procesado de Plano3D: de plano 2D (DXF, DWG, PDF) a pieza 3D con informe de verificación.
 La aplicación solo debe importar desde motor.api.
 """
--- a/motor/api.py
+++ b/motor/api.py
@ -0,0 +1,102 @@
 """Contrato entre el motor de procesado y la aplicación.
 Este módulo es lo único que la aplicación (interfaz y visor) conoce del motor.
 Si hay que cambiar algo de aquí, se acuerda entre los dos y se anota en docs/decisiones.md,
 porque rompe el trabajo del otro.
 Uso desde la aplicación:
    from motor.api import procesar, exportar, Opciones
    resultado = procesar("pieza.dxf", Opciones())
    if resultado.solido is not None:
        exportar(resultado.solido, "pieza.step")
 """
 from __future__ import annotations
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 import cadquery as cq
 class Estado(Enum):
    OK = "ok"                  # pieza reconstruida y sin problemas
    CON_AVISOS = "con_avisos"  # pieza reconstruida, pero hay cosas que revisar
    IMPOSIBLE = "imposible"    # no se ha podido reconstruir; ver los avisos bloqueantes
 class Gravedad(Enum):
    INFO = "info"              # dato informativo (p. ej. escala detectada)
    AVISO = "aviso"            # algo no cuadra, pero hay pieza
    BLOQUEANTE = "bloqueante"  # impide reconstruir; puede requerir un dato del usuario
@dataclass(frozen=True)
 class Segmento2D:
    """Línea de una vista, en coordenadas reales de la pieza (mm)."""
    x1: float
    y1: float
    x2: float
    y2: float
    oculta: bool = False
@dataclass
 class Vista:
    """Geometría 2D de una vista, para mostrarla junto al modelo 3D."""
    nombre: str                          # "alzado", "planta" o "perfil"
    segmentos: list[Segmento2D] = field(default_factory=list)
@dataclass
 class Referencia:
    """A qué parte del plano o de la pieza se refiere un aviso, para que el visor la resalte."""
    vista: str | None = None                                  # vista afectada, si la hay
    segmento: Segmento2D | None = None                        # línea del plano afectada
    punto: tuple[float, float, float] | None = None           # punto de la pieza 3D (mm)
@dataclass
 class Aviso:
    codigo: str                          # identificador estable, p. ej. "SIN_COTAS", "PROYECCION_MIXTA"
    mensaje: str                         # texto para el usuario, en español
    gravedad: Gravedad
    referencia: Referencia | None = None
@dataclass
 class Opciones:
    """Datos que el usuario puede aportar cuando el motor los pide."""
    escala: float | None = None          # factor real/dibujo si el plano no trae escala (1:2 -> 2.0)
    tolerancia: float = 1.0              # en unidades de dibujo
    alternativa: int | None = None       # si el plano es ambiguo, cuál de las piezas posibles se elige
@dataclass
 class Resultado:
    estado: Estado
    solido: cq.Shape | None              # pieza 3D en mm; None si el estado es IMPOSIBLE
    avisos: list[Aviso] = field(default_factory=list)
    vistas: dict[str, Vista] = field(default_factory=dict)
    escala: float = 1.0                  # factor aplicado (real/dibujo)
    alternativas: int = 1                # número de piezas compatibles con el plano
 def procesar(ruta_plano: str | Path, opciones: Opciones | None = None) -> Resultado:
    """Punto de entrada único del motor.
    Mientras el motor real no esté listo devuelve un resultado simulado (motor/simulado.py),
    para que la aplicación se pueda desarrollar en paralelo.
    """
    from motor import simulado
    return simulado.procesar(Path(ruta_plano), opciones or Opciones())
 def exportar(solido: cq.Shape, ruta_salida: str | Path) -> None:
    """Guarda la pieza en STEP o STL según la extensión del archivo."""
    ruta_salida = Path(ruta_salida)
    if ruta_salida.suffix.lower() not in (".step", ".stp", ".stl"):
        raise ValueError(f"Formato no admitido: {ruta_salida.suffix} (usa .step, .stp o .stl)")
    cq.exporters.export(cq.Workplane().add(solido), str(ruta_salida))
--- a/motor/simulado.py
+++ b/motor/simulado.py
@ -0,0 +1,45 @@
 """Motor simulado: devuelve siempre la pieza de CUBE01 con sus avisos reales.
 Sirve para desarrollar la aplicación (interfaz y visor) antes de que exista el motor real.
 Las líneas del plano sí se leen del archivo recibido, para poder dibujarlas en 2D.
 """
 from __future__ import annotations
 from pathlib import Path
 import cadquery as cq
 import ezdxf
 from motor.api import Aviso, Estado, Gravedad, Opciones, Referencia, Resultado, Segmento2D, Vista
 RAIZ = Path(__file__).resolve().parent.parent
 PIEZA_CUBE01 = RAIZ / "pruebas" / "catalogo" / "CUBE01" / "esperado.step"
 def _leer_lineas(ruta: Path) -> list[Segmento2D]:
    if ruta.suffix.lower() != ".dxf":
        return []
    doc = ezdxf.readfile(ruta)
    segmentos = []
    for e in doc.modelspace().query("LINE"):
        tipo = e.dxf.get("linetype", "ByLayer")
        if tipo.lower() == "bylayer":
            tipo = doc.layers.get(e.dxf.layer).dxf.linetype
        oculta = "HIDDEN" in tipo.upper() or "HIDDEN" in e.dxf.layer.upper()
        segmentos.append(Segmento2D(e.dxf.start.x, e.dxf.start.y, e.dxf.end.x, e.dxf.end.y, oculta))
    return segmentos
 def procesar(ruta: Path, opciones: Opciones) -> Resultado:
    solido = cq.importers.importStep(str(PIEZA_CUBE01)).val()
    avisos = [
        Aviso("ESCALA_DETECTADA", "Escala 1:2 leída del cajetín.", Gravedad.INFO),
        Aviso("SIN_COTAS", "El plano no tiene cotas: las medidas se deducen de la geometría y la escala.",
              Gravedad.AVISO),
        Aviso("PROYECCION_MIXTA",
              "Sistemas de proyección mezclados: la planta sigue el europeo (ISO-E) y el perfil el americano (ISO-A).",
              Gravedad.AVISO, Referencia(vista="perfil")),
    ]
    # Simulado: todas las líneas van en una sola "vista"; el motor real las separará en alzado, planta y perfil.
    vistas = {"plano": Vista("plano", _leer_lineas(ruta))}
    return Resultado(Estado.CON_AVISOS, solido, avisos, vistas, escala=opciones.escala or 2.0)
--- a/prototipo/README.md
+++ b/prototipo/README.md
@ -0,0 +1,11 @@
 # Prototipo (prueba técnica)
 `reconstruir.py` es la prueba técnica que demostró la viabilidad del proyecto con CUBE01.dxf: reconstrucción por descomposición en celdas, búsqueda por fuerza bruta y detección del sistema de proyección.
 Se conserva como referencia y no se modifica. El motor definitivo se desarrolla en `motor/`.
 ```bash
 uv run python prototipo/reconstruir.py pruebas/catalogo/CUBE01/plano.dxf
 ```
 Limitaciones conocidas: solo líneas rectas (sin arcos ni círculos) y búsqueda exhaustiva que no escala a más de unas 18 celdas.
--- a/prototipo/reconstruir.py
+++ b/prototipo/reconstruir.py
@ -0,0 +1,423 @@
 """Prueba técnica: reconstrucción automática de una pieza 3D a partir de un plano DXF
 con tres vistas (alzado, planta y perfil).
 Método (descomposición en celdas):
  1. Leer las líneas visibles y ocultas; ignorar marco, cajetín, textos y cotas.
  2. Buscar la escala en los textos del plano ("ESCALA 1:2").
  3. Agrupar las líneas en vistas e identificar alzado, planta y perfil por su alineación.
  4. Para cada convención de proyección posible (europea/americana en planta y perfil):
       a. dividir el volumen en celdas con todos los planos que sugieren las vistas
          (incluidos los planos inclinados de las líneas diagonales);
       b. descartar celdas que se salen de la silueta de alguna vista;
       c. probar combinaciones de celdas cuya silueta coincide con las tres vistas;
       d. proyectar las aristas del sólido (visibles y ocultas) y compararlas con el plano.
  5. Quedarse con el sólido que reproduce el plano y exportarlo a STEP y STL.
 Uso:  python reconstruir.py CUBE01.dxf
 """
 import itertools
 import math
 import re
 import sys
 from pathlib import Path
 import cadquery as cq
 import ezdxf
 import numpy as np
 from OCP.BRepClass3d import BRepClass3d_SolidClassifier
 from OCP.BRepIntCurveSurface import BRepIntCurveSurface_Inter
 from OCP.gp import gp_Dir, gp_Lin, gp_Pnt
 from OCP.TopAbs import TopAbs_IN
 from shapely.geometry import LineString, MultiPoint
 from shapely.ops import polygonize, unary_union
 TOL = 1.0          # tolerancia en unidades de dibujo (las vistas no están perfectamente alineadas)
 BIG = 1e4
 MAX_CELDAS = 18    # límite de la búsqueda exhaustiva (2^18 combinaciones)
 # ---------------------------------------------------------------- 1. lectura
 def leer_dxf(ruta):
    doc = ezdxf.readfile(ruta)
    msp = doc.modelspace()
    avisos = []
    def es_oculta(e):
        lt = e.dxf.get("linetype", "ByLayer")
        if lt.lower() in ("bylayer", "byblock"):
            lt = doc.layers.get(e.dxf.layer).dxf.linetype
        nombre = (lt + " " + e.dxf.layer).upper()
        return any(k in nombre for k in ("HIDDEN", "DASH", "OCULT", "ISO02"))
    segs = []
    for e in msp:
        if e.dxftype() == "LINE":
            partes = [(e.dxf.start, e.dxf.end)]
        elif e.dxftype() == "LWPOLYLINE":
            pts = [p[:2] for p in e.get_points()]
            if e.closed:
                pts.append(pts[0])
            partes = list(zip(pts, pts[1:]))
        else:
            continue  # marco y cajetín (INSERT), textos, cotas, etc.
        for a, b in partes:
            segs.append((float(a[0]), float(a[1]), float(b[0]), float(b[1]), es_oculta(e)))
    textos = [t.dxf.text for t in msp.query("TEXT")] + [t.text for t in msp.query("MTEXT")]
    for ins in msp.query("INSERT"):
        textos += [a.dxf.text for a in ins.attribs]
    escala = None
    for t in textos:
        m = re.search(r"(?:ESCALA|SCALE)\s*:?\s*(\d+(?:[.,]\d+)?)\s*[:/]\s*(\d+(?:[.,]\d+)?)", t, re.I)
        if m:
            a, b = (float(x.replace(",", ".")) for x in m.groups())
            escala = (a, b)
            break
    if escala is None:
        avisos.append("No se ha encontrado la escala en el plano: se supone 1:1.")
        escala = (1.0, 1.0)
    n_cotas = len(msp.query("DIMENSION"))
    if n_cotas == 0:
        avisos.append("El plano no tiene cotas: las medidas se deducen de la geometría y la escala.")
    unidades = {0: "sin unidades", 1: "pulgadas", 4: "mm", 5: "cm", 6: "m"}.get(doc.header.get("$INSUNITS", 0), "otras")
    return segs, escala, n_cotas, unidades, avisos
 # ---------------------------------------------------------------- 2. vistas
 def agrupar_vistas(segs):
    n = len(segs)
    padre = list(range(n))
    def raiz(i):
        while padre[i] != i:
            padre[i] = padre[padre[i]]
            i = padre[i]
        return i
    cajas = [(min(s[0], s[2]) - TOL, min(s[1], s[3]) - TOL, max(s[0], s[2]) + TOL, max(s[1], s[3]) + TOL) for s in segs]
    for i in range(n):
        for j in range(i + 1, n):
            a, b = cajas[i], cajas[j]
            if a[0] <= b[2] and b[0] <= a[2] and a[1] <= b[3] and b[1] <= a[3]:
                padre[raiz(i)] = raiz(j)
    grupos = {}
    for i in range(n):
        grupos.setdefault(raiz(i), []).append(segs[i])
    vistas = []
    for g in grupos.values():
        xs = [c for s in g for c in (s[0], s[2])]
        ys = [c for s in g for c in (s[1], s[3])]
        vistas.append({"segs": g, "u0": min(xs), "u1": max(xs), "v0": min(ys), "v1": max(ys)})
    return vistas
 def identificar_vistas(vistas):
    def mismo_ancho(a, b):
        return abs(a["u0"] - b["u0"]) < 2 * TOL and abs(a["u1"] - b["u1"]) < 2 * TOL
    def mismo_alto(a, b):
        return abs(a["v0"] - b["v0"]) < 2 * TOL and abs(a["v1"] - b["v1"]) < 2 * TOL
    for alz in vistas:
        plantas = [v for v in vistas if v is not alz and mismo_ancho(alz, v)]
        perfiles = [v for v in vistas if v is not alz and mismo_alto(alz, v)]
        if plantas and perfiles:
            pl, pf = plantas[0], perfiles[0]
            return alz, pl, pf, ("debajo" if pl["v1"] < alz["v0"] else "encima"), ("derecha" if pf["u0"] > alz["u1"] else "izquierda")
    raise SystemExit("No se han podido identificar alzado, planta y perfil alineados.")
 def a_coordenadas(alz, pl, pf, pos_pl, pos_pf, conv_pl, conv_pf):
    """Pasa cada vista a coordenadas de la pieza: alzado (X,Z), planta (X,Y), perfil (Y,Z).
    Y = 0 es la cara delantera. Devuelve también desde dónde mira el observador de cada vista."""
    D = pl["v1"] - pl["v0"]
    def map_pl(u, v):
        d = (pl["v1"] - v) if pos_pl == "debajo" else (v - pl["v0"])   # distancia al borde junto al alzado
        return (u - pl["u0"], D - d if conv_pl == "E" else d)
    def map_pf(u, v):
        d = (u - pf["u0"]) if pos_pf == "derecha" else (pf["u1"] - u)
        return (D - d if conv_pf == "E" else d, v - pf["v0"])
    def map_alz(u, v):
        return (u - alz["u0"], v - alz["v0"])
    out = {}
    for nombre, vista, f in (("alzado", alz, map_alz), ("planta", pl, map_pl), ("perfil", pf, map_pf)):
        out[nombre] = [(*f(s[0], s[1]), *f(s[2], s[3]), s[4]) for s in vista["segs"]]
    # Observador: en el sistema europeo la vista de debajo es la superior; en el americano, al revés.
    desde_arriba = (pos_pl == "debajo") == (conv_pl == "E")
    desde_izquierda = (pos_pf == "derecha") == (conv_pf == "E")
    observador = {
        "alzado": (0, -1, 0),
        "planta": (0, 0, 1) if desde_arriba else (0, 0, -1),
        "perfil": (-1, 0, 0) if desde_izquierda else (1, 0, 0),
    }
    return out, observador, D
 PROY = {"alzado": (0, 2), "planta": (0, 1), "perfil": (1, 2)}   # ejes 3D que se ven en cada vista
 # ---------------------------------------------------------------- 3. celdas
 def agrupar_valores(vals):
    vals = sorted(vals)
    out = []
    for v in vals:
        if not out or v - out[-1] > TOL:
            out.append(v)
    return out
 def region(segs):
    lineas = [LineString([(s[0], s[1]), (s[2], s[3])]) for s in segs if not s[4]]
    return unary_union(list(polygonize(unary_union(lineas))))
 def semiespacio(p, n):
    n = cq.Vector(*n).normalized()
    aux = cq.Vector(1, 0, 0) if abs(n.x) < 0.9 else cq.Vector(0, 1, 0)
    plano = cq.Plane(origin=cq.Vector(*p), xDir=aux.cross(n).normalized(), normal=n)
    return cq.Workplane(plano).rect(BIG, BIG).extrude(BIG).val()
 def crear_celdas(coords):
    rejilla = {0: [], 1: [], 2: []}
    inclinados = []
    for nombre, segs in coords.items():
        a, b = PROY[nombre]
        for x1, y1, x2, y2, _ in segs:
            rejilla[a] += [x1, x2]
            rejilla[b] += [y1, y2]
            if abs(x1 - x2) > TOL and abs(y1 - y2) > TOL:   # línea diagonal -> plano inclinado
                n = [0.0, 0.0, 0.0]
                n[a], n[b] = -(y2 - y1), (x2 - x1)
                p = [0.0, 0.0, 0.0]
                p[a], p[b] = x1, y1
                inclinados.append((tuple(p), tuple(n)))
    ejes = [agrupar_valores(rejilla[i]) for i in range(3)]
    celdas = []
    for i, j, k in itertools.product(range(len(ejes[0]) - 1), range(len(ejes[1]) - 1), range(len(ejes[2]) - 1)):
        x0, x1 = ejes[0][i], ejes[0][i + 1]
        y0, y1 = ejes[1][j], ejes[1][j + 1]
        z0, z1 = ejes[2][k], ejes[2][k + 1]
        trozos = [cq.Solid.makeBox(x1 - x0, y1 - y0, z1 - z0, pnt=cq.Vector(x0, y0, z0))]
        esquinas = np.array(list(itertools.product((x0, x1), (y0, y1), (z0, z1))))
        for p, n in inclinados:
            dist = (esquinas - np.array(p)) @ np.array(n)
            if dist.min() < -1e-6 and dist.max() > 1e-6:      # el plano atraviesa la caja
                hs = semiespacio(p, n)
                nuevos = []
                for t in trozos:
                    for parte in (t.intersect(hs), t.cut(hs)):
                        nuevos += [s for s in parte.Solids() if s.Volume() > 1e-6]
                trozos = nuevos
        celdas += trozos
    return celdas, ejes, inclinados
 def proyeccion(solido, nombre):
    a, b = PROY[nombre]
    pts = [(v.toTuple()[a], v.toTuple()[b]) for v in solido.Vertices()]
    return MultiPoint(pts).convex_hull
 # ---------------------------------------------------------------- 4. comparación
 def oculto(forma, p, d):
    inter = BRepIntCurveSurface_Inter()
    inter.Init(forma.wrapped, gp_Lin(gp_Pnt(*p), gp_Dir(*d)), 1e-7)
    ws = []
    while inter.More():
        if inter.W() > 1e-5:
            ws.append(inter.W())
        inter.Next()
    params = [0.0] + sorted(set(round(w, 6) for w in ws))
    for t0, t1 in zip(params, params[1:]):
        q = np.array(p) + np.array(d) * (t0 + t1) / 2
        if BRepClass3d_SolidClassifier(forma.wrapped, gp_Pnt(*q), 1e-6).State() == TopAbs_IN:
            return True
    return False
 def aristas_proyectadas(forma, nombre, obs):
    a, b = PROY[nombre]
    vis, ocu = [], []
    for e in forma.Edges():
        p0, p1 = np.array(e.startPoint().toTuple()), np.array(e.endPoint().toTuple())
        if math.dist((p0[a], p0[b]), (p1[a], p1[b])) < TOL / 2:
            continue                                   # arista perpendicular a la vista
        n = 5
        for i in range(n):
            q0, q1 = p0 + (p1 - p0) * i / n, p0 + (p1 - p0) * (i + 1) / n
            seg = (q0[a], q0[b], q1[a], q1[b])
            (ocu if oculto(forma, (q0 + q1) / 2, obs) else vis).append(seg)
    return vis, ocu
 def muestras(segs, paso=TOL / 2):
    pts = []
    for x1, y1, x2, y2 in segs:
        n = max(1, int(math.dist((x1, y1), (x2, y2)) / paso))
        for i in range(n):
            t = (i + 0.5) / n
            pts.append((x1 + (x2 - x1) * t, y1 + (y2 - y1) * t))
    return np.array(pts).reshape(-1, 2)
 def distancia(pts, segs):
    if len(pts) == 0:
        return np.zeros(0)
    if not segs:
        return np.full(len(pts), np.inf)
    s = np.array(segs, dtype=float)
    a, b = s[:, :2], s[:, 2:]
    ab = b - a
    t = np.clip(((pts[:, None, :] - a) * ab).sum(-1) / np.maximum((ab * ab).sum(-1), 1e-12), 0, 1)
    proj = a + t[..., None] * ab
    return np.linalg.norm(pts[:, None, :] - proj, axis=-1).min(axis=1)
 def errores_vista(forma, nombre, obs, dibujo):
    cvis, cocu = aristas_proyectadas(forma, nombre, obs)
    dvis = [s[:4] for s in dibujo if not s[4]]
    docu = [s[:4] for s in dibujo if s[4]]
    err = 0
    err += int((distancia(muestras(cvis), dvis) > TOL).sum())                 # aristas que el plano no tiene
    m = muestras(cocu)
    m = m[distancia(m, cvis) > TOL]                                           # lo visible tapa lo oculto
    err += int((distancia(m, docu) > TOL).sum())
    err += int((distancia(muestras(dvis), cvis) > TOL).sum())                 # líneas del plano que faltan
    err += int((distancia(muestras(docu), cocu) > TOL).sum())
    return err
 # ---------------------------------------------------------------- 5. búsqueda
 def reconstruir(coords, observador):
    regiones = {n: region(s) for n, s in coords.items()}
    celdas, ejes, inclinados = crear_celdas(coords)
    proy = [{n: proyeccion(c, n) for n in coords} for c in celdas]
    # Una celda que se sale de la silueta de alguna vista no puede formar parte de la pieza.
    validas = [i for i in range(len(celdas))
               if all(proy[i][n].difference(regiones[n].buffer(TOL / 2)).area < 1e-3 for n in coords)]
    if len(validas) > MAX_CELDAS:
        raise SystemExit(f"Demasiadas celdas ({len(validas)}) para la búsqueda exhaustiva de la prueba.")
    candidatos = []
    for r in range(1, len(validas) + 1):
        for combo in itertools.combinations(validas, r):
            ok = all(unary_union([proy[i][n] for i in combo]).symmetric_difference(regiones[n]).area
                     < 0.005 * regiones[n].area for n in coords)
            if ok:
                candidatos.append(combo)
    resultados = []
    for combo in candidatos:
        forma = celdas[combo[0]]
        if len(combo) > 1:
            forma = forma.fuse(*[celdas[i] for i in combo[1:]])
        forma = forma.clean()
        if len(forma.Solids()) != 1:
            continue                                   # piezas sueltas: no es una pieza única
        forma = forma.Solids()[0]
        err = sum(errores_vista(forma, n, observador[n], coords[n]) for n in coords)
        resultados.append((err, combo, forma))
        if err == 0 and len([r for r in resultados if r[0] == 0]) > 3:
            break
    resultados.sort(key=lambda r: r[0])
    return resultados, len(celdas), len(validas), len(candidatos), ejes, inclinados
 # ---------------------------------------------------------------- salida
 def vista_previa(forma, ruta_png):
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d.art3d import Poly3DCollection
    verts, tris = forma.tessellate(0.1)
    v = np.array([p.toTuple() for p in verts])
    caras = v[np.array(tris)]
    normales = np.cross(caras[:, 1] - caras[:, 0], caras[:, 2] - caras[:, 0])
    normales /= np.linalg.norm(normales, axis=1, keepdims=True) + 1e-12
    luz = np.clip(normales @ np.array([0.4, -0.6, 0.7]), 0.15, 1)
    fig = plt.figure(figsize=(6, 6))
    ax = fig.add_subplot(projection="3d")
    ax.add_collection3d(Poly3DCollection(caras, facecolors=plt.cm.Blues(0.35 + 0.55 * luz), edgecolor="none"))
    for e in forma.Edges():
        a, b = e.startPoint().toTuple(), e.endPoint().toTuple()
        ax.plot(*zip(a, b), color="k", lw=0.8)
    lo, hi = v.min(0), v.max(0)
    ax.set_xlim(lo[0], hi[0]); ax.set_ylim(lo[1], hi[1]); ax.set_zlim(lo[2], hi[2])
    ax.set_box_aspect(hi - lo)
    ax.set_xlabel("X (mm)"); ax.set_ylabel("Y (mm, 0 = frente)"); ax.set_zlabel("Z (mm)")
    ax.view_init(elev=25, azim=-60)
    plt.tight_layout()
    plt.savefig(ruta_png, dpi=110)
 def main(ruta):
    ruta = Path(ruta)
    segs, (ea, eb), n_cotas, unidades, avisos = leer_dxf(ruta)
    factor = eb / ea
    vistas = agrupar_vistas(segs)
    alz, pl, pf, pos_pl, pos_pf = identificar_vistas(vistas)
    inf = [f"# Informe de reconstrucción: {ruta.name}", "",
           f"- Líneas leídas: {len(segs)} ({sum(s[4] for s in segs)} ocultas); unidades del archivo: {unidades}",
           f"- Escala: {ea:g}:{eb:g} -> factor x{factor:g}; cotas en el plano: {n_cotas}",
           f"- Vistas encontradas: {len(vistas)}; planta {pos_pl} del alzado, perfil a la {pos_pf}",
           f"- Desalineación planta/alzado: {abs(pl['u0'] - alz['u0']):.2f}; perfil/alzado: {abs(pf['v0'] - alz['v0']):.2f} (unidades de dibujo)"]
    D_pf = pf["u1"] - pf["u0"]
    D_pl = pl["v1"] - pl["v0"]
    if abs(D_pf - D_pl) > 2 * TOL:
        avisos.append(f"La profundidad no coincide entre planta ({D_pl:.1f}) y perfil ({D_pf:.1f}).")
    nombres = {"E": "europeo (ISO-E)", "A": "americano (ISO-A)"}
    mejor = None
    inf += ["", "## Hipótesis de proyección", "", "| Planta | Perfil | Celdas (válidas) | Candidatos por silueta | Error mínimo |", "|---|---|---|---|---|"]
    for conv_pl, conv_pf in itertools.product("EA", repeat=2):
        coords, obs, D = a_coordenadas(alz, pl, pf, pos_pl, pos_pf, conv_pl, conv_pf)
        res, n_c, n_v, n_cand, ejes, incl = reconstruir(coords, obs)
        e_min = res[0][0] if res else "-"
        inf.append(f"| {nombres[conv_pl]} | {nombres[conv_pf]} | {n_c} ({n_v}) | {n_cand} | {e_min} |")
        print(f"planta {conv_pl} / perfil {conv_pf}: celdas {n_c}, validas {n_v}, candidatos {n_cand}, error {e_min}")
        if res and (mejor is None or res[0][0] < mejor[0][0][0]):
            mejor = (res, conv_pl, conv_pf)
    if mejor is None:
        raise SystemExit("No se ha encontrado ninguna pieza compatible con las vistas.")
    res, conv_pl, conv_pf = mejor
    err, combo, forma = res[0]
    exactas = [r for r in res if r[0] == 0]
    if conv_pl != conv_pf:
        avisos.append(f"Sistemas de proyección mezclados: la planta sigue el sistema {nombres[conv_pl]} "
                      f"y el perfil el {nombres[conv_pf]}.")
    if err > 0:
        avisos.append(f"Ninguna pieza reproduce exactamente el plano (error mínimo {err}): revisar manualmente.")
    if len(exactas) > 1:
        avisos.append(f"Hay {len(exactas)} piezas distintas que encajan con las vistas: el plano es ambiguo.")
    forma = forma.scale(factor)
    bb = forma.BoundingBox()
    inf += ["", "## Resultado", "",
            f"- Convención elegida: planta {nombres[conv_pl]}, perfil {nombres[conv_pf]}",
            f"- Celdas usadas: {len(combo)}; error de reproducción del plano: {err}",
            f"- Tamaño real: {bb.xlen:.1f} x {bb.ylen:.1f} x {bb.zlen:.1f} mm; volumen {forma.Volume():.0f} mm³",
            f"- Caras: {len(forma.Faces())}, aristas: {len(forma.Edges())}",
            "", "## Avisos", ""] + [f"- {a}" for a in avisos]
    base = ruta.with_suffix("")
    cq.exporters.export(cq.Workplane().add(forma), str(base) + ".step")
    cq.exporters.export(cq.Workplane().add(forma), str(base) + ".stl")
    vista_previa(forma, str(base) + "_3d.png")
    Path(str(base) + "_informe.md").write_text("\n".join(inf) + "\n", encoding="utf-8")
    print("\n".join(inf))
 if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else "CUBE01.dxf")
--- a/pruebas/catalogo/CUBE01/esperado.step
+++ b/pruebas/catalogo/CUBE01/esperado.step
@ -0,0 +1,721 @@
 ISO-10303-21;
 HEADER;
 FILE_DESCRIPTION(('Open CASCADE Model'),'2;1');
 FILE_NAME('Open CASCADE Shape Model','2026-10-08T19:20:47',('Author'),(
    'Open CASCADE'),'Open CASCADE STEP processor 7.9','Open CASCADE 7.9'
  ,'Unknown');
 FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }'));
 ENDSEC;
 DATA;
 #1 = APPLICATION_PROTOCOL_DEFINITION('international standard',
  'automotive_design',2000,#2);
 #2 = APPLICATION_CONTEXT(
  'core data for automotive mechanical design processes');
 #3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10);
 #4 = PRODUCT_DEFINITION_SHAPE('','',#5);
 #5 = PRODUCT_DEFINITION('design','',#6,#9);
 #6 = PRODUCT_DEFINITION_FORMATION('','',#7);
 #7 = PRODUCT('Open CASCADE STEP translator 7.9 1',
  'Open CASCADE STEP translator 7.9 1','',(#8));
 #8 = PRODUCT_CONTEXT('',#2,'mechanical');
 #9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design');
 #10 = ADVANCED_BREP_SHAPE_REPRESENTATION('',(#11,#15),#609);
 #11 = AXIS2_PLACEMENT_3D('',#12,#13,#14);
 #12 = CARTESIAN_POINT('',(0.,0.,0.));
 #13 = DIRECTION('',(0.,0.,1.));
 #14 = DIRECTION('',(1.,0.,-0.));
 #15 = MANIFOLD_SOLID_BREP('',#16);
 #16 = CLOSED_SHELL('',(#17,#193,#269,#322,#398,#492,#519,#547,#574,#601)
  );
 #17 = ADVANCED_FACE('',(#18),#32,.F.);
 #18 = FACE_BOUND('',#19,.F.);
 #19 = EDGE_LOOP('',(#20,#55,#83,#111,#139,#167));
 #20 = ORIENTED_EDGE('',*,*,#21,.F.);
 #21 = EDGE_CURVE('',#22,#24,#26,.T.);
 #22 = VERTEX_POINT('',#23);
 #23 = CARTESIAN_POINT('',(0.,0.,0.));
 #24 = VERTEX_POINT('',#25);
 #25 = CARTESIAN_POINT('',(0.,0.,100.));
 #26 = SURFACE_CURVE('',#27,(#31,#43),.PCURVE_S1.);
 #27 = LINE('',#28,#29);
 #28 = CARTESIAN_POINT('',(0.,0.,0.));
 #29 = VECTOR('',#30,1.);
 #30 = DIRECTION('',(0.,0.,1.));
 #31 = PCURVE('',#32,#37);
 #32 = PLANE('',#33);
 #33 = AXIS2_PLACEMENT_3D('',#34,#35,#36);
 #34 = CARTESIAN_POINT('',(0.,0.,0.));
 #35 = DIRECTION('',(1.,0.,-0.));
 #36 = DIRECTION('',(0.,0.,1.));
 #37 = DEFINITIONAL_REPRESENTATION('',(#38),#42);
 #38 = LINE('',#39,#40);
 #39 = CARTESIAN_POINT('',(0.,0.));
 #40 = VECTOR('',#41,1.);
 #41 = DIRECTION('',(1.,0.));
 #42 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #43 = PCURVE('',#44,#49);
 #44 = PLANE('',#45);
 #45 = AXIS2_PLACEMENT_3D('',#46,#47,#48);
 #46 = CARTESIAN_POINT('',(0.,0.,0.));
 #47 = DIRECTION('',(-0.,1.,0.));
 #48 = DIRECTION('',(0.,0.,1.));
 #49 = DEFINITIONAL_REPRESENTATION('',(#50),#54);
 #50 = LINE('',#51,#52);
 #51 = CARTESIAN_POINT('',(0.,0.));
 #52 = VECTOR('',#53,1.);
 #53 = DIRECTION('',(1.,0.));
 #54 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #55 = ORIENTED_EDGE('',*,*,#56,.F.);
 #56 = EDGE_CURVE('',#57,#22,#59,.T.);
 #57 = VERTEX_POINT('',#58);
 #58 = CARTESIAN_POINT('',(0.,200.,0.));
 #59 = SURFACE_CURVE('',#60,(#64,#71),.PCURVE_S1.);
 #60 = LINE('',#61,#62);
 #61 = CARTESIAN_POINT('',(0.,200.,0.));
 #62 = VECTOR('',#63,1.);
 #63 = DIRECTION('',(0.,-1.,0.));
 #64 = PCURVE('',#32,#65);
 #65 = DEFINITIONAL_REPRESENTATION('',(#66),#70);
 #66 = LINE('',#67,#68);
 #67 = CARTESIAN_POINT('',(0.,-200.));
 #68 = VECTOR('',#69,1.);
 #69 = DIRECTION('',(0.,1.));
 #70 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #71 = PCURVE('',#72,#77);
 #72 = PLANE('',#73);
 #73 = AXIS2_PLACEMENT_3D('',#74,#75,#76);
 #74 = CARTESIAN_POINT('',(0.,0.,0.));
 #75 = DIRECTION('',(0.,0.,1.));
 #76 = DIRECTION('',(1.,0.,-0.));
 #77 = DEFINITIONAL_REPRESENTATION('',(#78),#82);
 #78 = LINE('',#79,#80);
 #79 = CARTESIAN_POINT('',(0.,200.));
 #80 = VECTOR('',#81,1.);
 #81 = DIRECTION('',(0.,-1.));
 #82 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #83 = ORIENTED_EDGE('',*,*,#84,.F.);
 #84 = EDGE_CURVE('',#85,#57,#87,.T.);
 #85 = VERTEX_POINT('',#86);
 #86 = CARTESIAN_POINT('',(0.,200.,200.));
 #87 = SURFACE_CURVE('',#88,(#92,#99),.PCURVE_S1.);
 #88 = LINE('',#89,#90);
 #89 = CARTESIAN_POINT('',(0.,200.,200.));
 #90 = VECTOR('',#91,1.);
 #91 = DIRECTION('',(0.,0.,-1.));
 #92 = PCURVE('',#32,#93);
 #93 = DEFINITIONAL_REPRESENTATION('',(#94),#98);
 #94 = LINE('',#95,#96);
 #95 = CARTESIAN_POINT('',(200.,-200.));
 #96 = VECTOR('',#97,1.);
 #97 = DIRECTION('',(-1.,0.));
 #98 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #99 = PCURVE('',#100,#105);
 #100 = PLANE('',#101);
 #101 = AXIS2_PLACEMENT_3D('',#102,#103,#104);
 #102 = CARTESIAN_POINT('',(0.,200.,0.));
 #103 = DIRECTION('',(-0.,1.,0.));
 #104 = DIRECTION('',(0.,0.,1.));
 #105 = DEFINITIONAL_REPRESENTATION('',(#106),#110);
 #106 = LINE('',#107,#108);
 #107 = CARTESIAN_POINT('',(200.,0.));
 #108 = VECTOR('',#109,1.);
 #109 = DIRECTION('',(-1.,0.));
 #110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #111 = ORIENTED_EDGE('',*,*,#112,.F.);
 #112 = EDGE_CURVE('',#113,#85,#115,.T.);
 #113 = VERTEX_POINT('',#114);
 #114 = CARTESIAN_POINT('',(0.,100.,200.));
 #115 = SURFACE_CURVE('',#116,(#120,#127),.PCURVE_S1.);
 #116 = LINE('',#117,#118);
 #117 = CARTESIAN_POINT('',(0.,100.,200.));
 #118 = VECTOR('',#119,1.);
 #119 = DIRECTION('',(-0.,1.,0.));
 #120 = PCURVE('',#32,#121);
 #121 = DEFINITIONAL_REPRESENTATION('',(#122),#126);
 #122 = LINE('',#123,#124);
 #123 = CARTESIAN_POINT('',(200.,-100.));
 #124 = VECTOR('',#125,1.);
 #125 = DIRECTION('',(0.,-1.));
 #126 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #127 = PCURVE('',#128,#133);
 #128 = PLANE('',#129);
 #129 = AXIS2_PLACEMENT_3D('',#130,#131,#132);
 #130 = CARTESIAN_POINT('',(0.,100.,200.));
 #131 = DIRECTION('',(0.,0.,1.));
 #132 = DIRECTION('',(1.,0.,-0.));
 #133 = DEFINITIONAL_REPRESENTATION('',(#134),#138);
 #134 = LINE('',#135,#136);
 #135 = CARTESIAN_POINT('',(0.,0.));
 #136 = VECTOR('',#137,1.);
 #137 = DIRECTION('',(0.,1.));
 #138 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #139 = ORIENTED_EDGE('',*,*,#140,.F.);
 #140 = EDGE_CURVE('',#141,#113,#143,.T.);
 #141 = VERTEX_POINT('',#142);
 #142 = CARTESIAN_POINT('',(0.,100.,100.));
 #143 = SURFACE_CURVE('',#144,(#148,#155),.PCURVE_S1.);
 #144 = LINE('',#145,#146);
 #145 = CARTESIAN_POINT('',(0.,100.,100.));
 #146 = VECTOR('',#147,1.);
 #147 = DIRECTION('',(0.,0.,1.));
 #148 = PCURVE('',#32,#149);
 #149 = DEFINITIONAL_REPRESENTATION('',(#150),#154);
 #150 = LINE('',#151,#152);
 #151 = CARTESIAN_POINT('',(100.,-100.));
 #152 = VECTOR('',#153,1.);
 #153 = DIRECTION('',(1.,0.));
 #154 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #155 = PCURVE('',#156,#161);
 #156 = PLANE('',#157);
 #157 = AXIS2_PLACEMENT_3D('',#158,#159,#160);
 #158 = CARTESIAN_POINT('',(0.,100.,100.));
 #159 = DIRECTION('',(-0.,1.,0.));
 #160 = DIRECTION('',(0.,0.,1.));
 #161 = DEFINITIONAL_REPRESENTATION('',(#162),#166);
 #162 = LINE('',#163,#164);
 #163 = CARTESIAN_POINT('',(0.,0.));
 #164 = VECTOR('',#165,1.);
 #165 = DIRECTION('',(1.,0.));
 #166 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #167 = ORIENTED_EDGE('',*,*,#168,.F.);
 #168 = EDGE_CURVE('',#24,#141,#169,.T.);
 #169 = SURFACE_CURVE('',#170,(#174,#181),.PCURVE_S1.);
 #170 = LINE('',#171,#172);
 #171 = CARTESIAN_POINT('',(0.,0.,100.));
 #172 = VECTOR('',#173,1.);
 #173 = DIRECTION('',(-0.,1.,0.));
 #174 = PCURVE('',#32,#175);
 #175 = DEFINITIONAL_REPRESENTATION('',(#176),#180);
 #176 = LINE('',#177,#178);
 #177 = CARTESIAN_POINT('',(100.,0.));
 #178 = VECTOR('',#179,1.);
 #179 = DIRECTION('',(0.,-1.));
 #180 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #181 = PCURVE('',#182,#187);
 #182 = PLANE('',#183);
 #183 = AXIS2_PLACEMENT_3D('',#184,#185,#186);
 #184 = CARTESIAN_POINT('',(0.,0.,100.));
 #185 = DIRECTION('',(0.,0.,1.));
 #186 = DIRECTION('',(1.,0.,-0.));
 #187 = DEFINITIONAL_REPRESENTATION('',(#188),#192);
 #188 = LINE('',#189,#190);
 #189 = CARTESIAN_POINT('',(0.,0.));
 #190 = VECTOR('',#191,1.);
 #191 = DIRECTION('',(0.,1.));
 #192 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #193 = ADVANCED_FACE('',(#194),#182,.T.);
 #194 = FACE_BOUND('',#195,.T.);
 #195 = EDGE_LOOP('',(#196,#197,#220,#248));
 #196 = ORIENTED_EDGE('',*,*,#168,.F.);
 #197 = ORIENTED_EDGE('',*,*,#198,.T.);
 #198 = EDGE_CURVE('',#24,#199,#201,.T.);
 #199 = VERTEX_POINT('',#200);
 #200 = CARTESIAN_POINT('',(100.,0.,100.));
 #201 = SURFACE_CURVE('',#202,(#206,#213),.PCURVE_S1.);
 #202 = LINE('',#203,#204);
 #203 = CARTESIAN_POINT('',(0.,0.,100.));
 #204 = VECTOR('',#205,1.);
 #205 = DIRECTION('',(1.,0.,-0.));
 #206 = PCURVE('',#182,#207);
 #207 = DEFINITIONAL_REPRESENTATION('',(#208),#212);
 #208 = LINE('',#209,#210);
 #209 = CARTESIAN_POINT('',(0.,0.));
 #210 = VECTOR('',#211,1.);
 #211 = DIRECTION('',(1.,0.));
 #212 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #213 = PCURVE('',#44,#214);
 #214 = DEFINITIONAL_REPRESENTATION('',(#215),#219);
 #215 = LINE('',#216,#217);
 #216 = CARTESIAN_POINT('',(100.,0.));
 #217 = VECTOR('',#218,1.);
 #218 = DIRECTION('',(0.,1.));
 #219 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #220 = ORIENTED_EDGE('',*,*,#221,.T.);
 #221 = EDGE_CURVE('',#199,#222,#224,.T.);
 #222 = VERTEX_POINT('',#223);
 #223 = CARTESIAN_POINT('',(100.,100.,100.));
 #224 = SURFACE_CURVE('',#225,(#229,#236),.PCURVE_S1.);
 #225 = LINE('',#226,#227);
 #226 = CARTESIAN_POINT('',(100.,0.,100.));
 #227 = VECTOR('',#228,1.);
 #228 = DIRECTION('',(-0.,1.,0.));
 #229 = PCURVE('',#182,#230);
 #230 = DEFINITIONAL_REPRESENTATION('',(#231),#235);
 #231 = LINE('',#232,#233);
 #232 = CARTESIAN_POINT('',(100.,0.));
 #233 = VECTOR('',#234,1.);
 #234 = DIRECTION('',(0.,1.));
 #235 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #236 = PCURVE('',#237,#242);
 #237 = PLANE('',#238);
 #238 = AXIS2_PLACEMENT_3D('',#239,#240,#241);
 #239 = CARTESIAN_POINT('',(100.,0.,100.));
 #240 = DIRECTION('',(1.,0.,-0.));
 #241 = DIRECTION('',(0.,0.,1.));
 #242 = DEFINITIONAL_REPRESENTATION('',(#243),#247);
 #243 = LINE('',#244,#245);
 #244 = CARTESIAN_POINT('',(0.,0.));
 #245 = VECTOR('',#246,1.);
 #246 = DIRECTION('',(0.,-1.));
 #247 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #248 = ORIENTED_EDGE('',*,*,#249,.F.);
 #249 = EDGE_CURVE('',#141,#222,#250,.T.);
 #250 = SURFACE_CURVE('',#251,(#255,#262),.PCURVE_S1.);
 #251 = LINE('',#252,#253);
 #252 = CARTESIAN_POINT('',(0.,100.,100.));
 #253 = VECTOR('',#254,1.);
 #254 = DIRECTION('',(1.,0.,-0.));
 #255 = PCURVE('',#182,#256);
 #256 = DEFINITIONAL_REPRESENTATION('',(#257),#261);
 #257 = LINE('',#258,#259);
 #258 = CARTESIAN_POINT('',(0.,100.));
 #259 = VECTOR('',#260,1.);
 #260 = DIRECTION('',(1.,0.));
 #261 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #262 = PCURVE('',#156,#263);
 #263 = DEFINITIONAL_REPRESENTATION('',(#264),#268);
 #264 = LINE('',#265,#266);
 #265 = CARTESIAN_POINT('',(0.,0.));
 #266 = VECTOR('',#267,1.);
 #267 = DIRECTION('',(0.,1.));
 #268 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #269 = ADVANCED_FACE('',(#270),#237,.F.);
 #270 = FACE_BOUND('',#271,.F.);
 #271 = EDGE_LOOP('',(#272,#300,#301));
 #272 = ORIENTED_EDGE('',*,*,#273,.F.);
 #273 = EDGE_CURVE('',#199,#274,#276,.T.);
 #274 = VERTEX_POINT('',#275);
 #275 = CARTESIAN_POINT('',(100.,100.,200.));
 #276 = SURFACE_CURVE('',#277,(#281,#288),.PCURVE_S1.);
 #277 = LINE('',#278,#279);
 #278 = CARTESIAN_POINT('',(100.,50.,150.));
 #279 = VECTOR('',#280,1.);
 #280 = DIRECTION('',(0.,0.707106781187,0.707106781187));
 #281 = PCURVE('',#237,#282);
 #282 = DEFINITIONAL_REPRESENTATION('',(#283),#287);
 #283 = LINE('',#284,#285);
 #284 = CARTESIAN_POINT('',(50.,-50.));
 #285 = VECTOR('',#286,1.);
 #286 = DIRECTION('',(0.707106781187,-0.707106781187));
 #287 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #288 = PCURVE('',#289,#294);
 #289 = PLANE('',#290);
 #290 = AXIS2_PLACEMENT_3D('',#291,#292,#293);
 #291 = CARTESIAN_POINT('',(0.,100.,200.));
 #292 = DIRECTION('',(0.,0.707106781187,-0.707106781187));
 #293 = DIRECTION('',(0.,0.707106781187,0.707106781187));
 #294 = DEFINITIONAL_REPRESENTATION('',(#295),#299);
 #295 = LINE('',#296,#297);
 #296 = CARTESIAN_POINT('',(-70.71067811865,100.));
 #297 = VECTOR('',#298,1.);
 #298 = DIRECTION('',(1.,0.));
 #299 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #300 = ORIENTED_EDGE('',*,*,#221,.T.);
 #301 = ORIENTED_EDGE('',*,*,#302,.T.);
 #302 = EDGE_CURVE('',#222,#274,#303,.T.);
 #303 = SURFACE_CURVE('',#304,(#308,#315),.PCURVE_S1.);
 #304 = LINE('',#305,#306);
 #305 = CARTESIAN_POINT('',(100.,100.,100.));
 #306 = VECTOR('',#307,1.);
 #307 = DIRECTION('',(0.,0.,1.));
 #308 = PCURVE('',#237,#309);
 #309 = DEFINITIONAL_REPRESENTATION('',(#310),#314);
 #310 = LINE('',#311,#312);
 #311 = CARTESIAN_POINT('',(0.,-100.));
 #312 = VECTOR('',#313,1.);
 #313 = DIRECTION('',(1.,0.));
 #314 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #315 = PCURVE('',#156,#316);
 #316 = DEFINITIONAL_REPRESENTATION('',(#317),#321);
 #317 = LINE('',#318,#319);
 #318 = CARTESIAN_POINT('',(0.,100.));
 #319 = VECTOR('',#320,1.);
 #320 = DIRECTION('',(1.,0.));
 #321 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #322 = ADVANCED_FACE('',(#323),#289,.F.);
 #323 = FACE_BOUND('',#324,.F.);
 #324 = EDGE_LOOP('',(#325,#355,#376,#377));
 #325 = ORIENTED_EDGE('',*,*,#326,.F.);
 #326 = EDGE_CURVE('',#327,#329,#331,.T.);
 #327 = VERTEX_POINT('',#328);
 #328 = CARTESIAN_POINT('',(200.,0.,100.));
 #329 = VERTEX_POINT('',#330);
 #330 = CARTESIAN_POINT('',(200.,100.,200.));
 #331 = SURFACE_CURVE('',#332,(#336,#343),.PCURVE_S1.);
 #332 = LINE('',#333,#334);
 #333 = CARTESIAN_POINT('',(200.,50.,150.));
 #334 = VECTOR('',#335,1.);
 #335 = DIRECTION('',(0.,0.707106781187,0.707106781187));
 #336 = PCURVE('',#289,#337);
 #337 = DEFINITIONAL_REPRESENTATION('',(#338),#342);
 #338 = LINE('',#339,#340);
 #339 = CARTESIAN_POINT('',(-70.71067811865,200.));
 #340 = VECTOR('',#341,1.);
 #341 = DIRECTION('',(1.,0.));
 #342 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #343 = PCURVE('',#344,#349);
 #344 = PLANE('',#345);
 #345 = AXIS2_PLACEMENT_3D('',#346,#347,#348);
 #346 = CARTESIAN_POINT('',(200.,0.,0.));
 #347 = DIRECTION('',(1.,0.,-0.));
 #348 = DIRECTION('',(0.,0.,1.));
 #349 = DEFINITIONAL_REPRESENTATION('',(#350),#354);
 #350 = LINE('',#351,#352);
 #351 = CARTESIAN_POINT('',(150.,-50.));
 #352 = VECTOR('',#353,1.);
 #353 = DIRECTION('',(0.707106781187,-0.707106781187));
 #354 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #355 = ORIENTED_EDGE('',*,*,#356,.F.);
 #356 = EDGE_CURVE('',#199,#327,#357,.T.);
 #357 = SURFACE_CURVE('',#358,(#362,#369),.PCURVE_S1.);
 #358 = LINE('',#359,#360);
 #359 = CARTESIAN_POINT('',(100.,0.,100.));
 #360 = VECTOR('',#361,1.);
 #361 = DIRECTION('',(1.,0.,-0.));
 #362 = PCURVE('',#289,#363);
 #363 = DEFINITIONAL_REPRESENTATION('',(#364),#368);
 #364 = LINE('',#365,#366);
 #365 = CARTESIAN_POINT('',(-141.4213562373,100.));
 #366 = VECTOR('',#367,1.);
 #367 = DIRECTION('',(0.,1.));
 #368 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #369 = PCURVE('',#44,#370);
 #370 = DEFINITIONAL_REPRESENTATION('',(#371),#375);
 #371 = LINE('',#372,#373);
 #372 = CARTESIAN_POINT('',(100.,100.));
 #373 = VECTOR('',#374,1.);
 #374 = DIRECTION('',(0.,1.));
 #375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #376 = ORIENTED_EDGE('',*,*,#273,.T.);
 #377 = ORIENTED_EDGE('',*,*,#378,.T.);
 #378 = EDGE_CURVE('',#274,#329,#379,.T.);
 #379 = SURFACE_CURVE('',#380,(#384,#391),.PCURVE_S1.);
 #380 = LINE('',#381,#382);
 #381 = CARTESIAN_POINT('',(100.,100.,200.));
 #382 = VECTOR('',#383,1.);
 #383 = DIRECTION('',(1.,0.,-0.));
 #384 = PCURVE('',#289,#385);
 #385 = DEFINITIONAL_REPRESENTATION('',(#386),#390);
 #386 = LINE('',#387,#388);
 #387 = CARTESIAN_POINT('',(0.,100.));
 #388 = VECTOR('',#389,1.);
 #389 = DIRECTION('',(0.,1.));
 #390 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #391 = PCURVE('',#128,#392);
 #392 = DEFINITIONAL_REPRESENTATION('',(#393),#397);
 #393 = LINE('',#394,#395);
 #394 = CARTESIAN_POINT('',(100.,0.));
 #395 = VECTOR('',#396,1.);
 #396 = DIRECTION('',(1.,0.));
 #397 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #398 = ADVANCED_FACE('',(#399),#344,.T.);
 #399 = FACE_BOUND('',#400,.T.);
 #400 = EDGE_LOOP('',(#401,#424,#447,#470,#491));
 #401 = ORIENTED_EDGE('',*,*,#402,.F.);
 #402 = EDGE_CURVE('',#403,#327,#405,.T.);
 #403 = VERTEX_POINT('',#404);
 #404 = CARTESIAN_POINT('',(200.,0.,0.));
 #405 = SURFACE_CURVE('',#406,(#410,#417),.PCURVE_S1.);
 #406 = LINE('',#407,#408);
 #407 = CARTESIAN_POINT('',(200.,0.,0.));
 #408 = VECTOR('',#409,1.);
 #409 = DIRECTION('',(0.,0.,1.));
 #410 = PCURVE('',#344,#411);
 #411 = DEFINITIONAL_REPRESENTATION('',(#412),#416);
 #412 = LINE('',#413,#414);
 #413 = CARTESIAN_POINT('',(0.,0.));
 #414 = VECTOR('',#415,1.);
 #415 = DIRECTION('',(1.,0.));
 #416 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #417 = PCURVE('',#44,#418);
 #418 = DEFINITIONAL_REPRESENTATION('',(#419),#423);
 #419 = LINE('',#420,#421);
 #420 = CARTESIAN_POINT('',(0.,200.));
 #421 = VECTOR('',#422,1.);
 #422 = DIRECTION('',(1.,0.));
 #423 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #424 = ORIENTED_EDGE('',*,*,#425,.F.);
 #425 = EDGE_CURVE('',#426,#403,#428,.T.);
 #426 = VERTEX_POINT('',#427);
 #427 = CARTESIAN_POINT('',(200.,200.,0.));
 #428 = SURFACE_CURVE('',#429,(#433,#440),.PCURVE_S1.);
 #429 = LINE('',#430,#431);
 #430 = CARTESIAN_POINT('',(200.,200.,0.));
 #431 = VECTOR('',#432,1.);
 #432 = DIRECTION('',(0.,-1.,0.));
 #433 = PCURVE('',#344,#434);
 #434 = DEFINITIONAL_REPRESENTATION('',(#435),#439);
 #435 = LINE('',#436,#437);
 #436 = CARTESIAN_POINT('',(0.,-200.));
 #437 = VECTOR('',#438,1.);
 #438 = DIRECTION('',(0.,1.));
 #439 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #440 = PCURVE('',#72,#441);
 #441 = DEFINITIONAL_REPRESENTATION('',(#442),#446);
 #442 = LINE('',#443,#444);
 #443 = CARTESIAN_POINT('',(200.,200.));
 #444 = VECTOR('',#445,1.);
 #445 = DIRECTION('',(0.,-1.));
 #446 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #447 = ORIENTED_EDGE('',*,*,#448,.F.);
 #448 = EDGE_CURVE('',#449,#426,#451,.T.);
 #449 = VERTEX_POINT('',#450);
 #450 = CARTESIAN_POINT('',(200.,200.,200.));
 #451 = SURFACE_CURVE('',#452,(#456,#463),.PCURVE_S1.);
 #452 = LINE('',#453,#454);
 #453 = CARTESIAN_POINT('',(200.,200.,200.));
 #454 = VECTOR('',#455,1.);
 #455 = DIRECTION('',(0.,0.,-1.));
 #456 = PCURVE('',#344,#457);
 #457 = DEFINITIONAL_REPRESENTATION('',(#458),#462);
 #458 = LINE('',#459,#460);
 #459 = CARTESIAN_POINT('',(200.,-200.));
 #460 = VECTOR('',#461,1.);
 #461 = DIRECTION('',(-1.,0.));
 #462 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #463 = PCURVE('',#100,#464);
 #464 = DEFINITIONAL_REPRESENTATION('',(#465),#469);
 #465 = LINE('',#466,#467);
 #466 = CARTESIAN_POINT('',(200.,200.));
 #467 = VECTOR('',#468,1.);
 #468 = DIRECTION('',(-1.,0.));
 #469 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #470 = ORIENTED_EDGE('',*,*,#471,.F.);
 #471 = EDGE_CURVE('',#329,#449,#472,.T.);
 #472 = SURFACE_CURVE('',#473,(#477,#484),.PCURVE_S1.);
 #473 = LINE('',#474,#475);
 #474 = CARTESIAN_POINT('',(200.,100.,200.));
 #475 = VECTOR('',#476,1.);
 #476 = DIRECTION('',(-0.,1.,0.));
 #477 = PCURVE('',#344,#478);
 #478 = DEFINITIONAL_REPRESENTATION('',(#479),#483);
 #479 = LINE('',#480,#481);
 #480 = CARTESIAN_POINT('',(200.,-100.));
 #481 = VECTOR('',#482,1.);
 #482 = DIRECTION('',(0.,-1.));
 #483 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #484 = PCURVE('',#128,#485);
 #485 = DEFINITIONAL_REPRESENTATION('',(#486),#490);
 #486 = LINE('',#487,#488);
 #487 = CARTESIAN_POINT('',(200.,0.));
 #488 = VECTOR('',#489,1.);
 #489 = DIRECTION('',(0.,1.));
 #490 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #491 = ORIENTED_EDGE('',*,*,#326,.F.);
 #492 = ADVANCED_FACE('',(#493),#156,.F.);
 #493 = FACE_BOUND('',#494,.F.);
 #494 = EDGE_LOOP('',(#495,#496,#497,#518));
 #495 = ORIENTED_EDGE('',*,*,#249,.F.);
 #496 = ORIENTED_EDGE('',*,*,#140,.T.);
 #497 = ORIENTED_EDGE('',*,*,#498,.T.);
 #498 = EDGE_CURVE('',#113,#274,#499,.T.);
 #499 = SURFACE_CURVE('',#500,(#504,#511),.PCURVE_S1.);
 #500 = LINE('',#501,#502);
 #501 = CARTESIAN_POINT('',(0.,100.,200.));
 #502 = VECTOR('',#503,1.);
 #503 = DIRECTION('',(1.,0.,-0.));
 #504 = PCURVE('',#156,#505);
 #505 = DEFINITIONAL_REPRESENTATION('',(#506),#510);
 #506 = LINE('',#507,#508);
 #507 = CARTESIAN_POINT('',(100.,0.));
 #508 = VECTOR('',#509,1.);
 #509 = DIRECTION('',(0.,1.));
 #510 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #511 = PCURVE('',#128,#512);
 #512 = DEFINITIONAL_REPRESENTATION('',(#513),#517);
 #513 = LINE('',#514,#515);
 #514 = CARTESIAN_POINT('',(0.,0.));
 #515 = VECTOR('',#516,1.);
 #516 = DIRECTION('',(1.,0.));
 #517 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #518 = ORIENTED_EDGE('',*,*,#302,.F.);
 #519 = ADVANCED_FACE('',(#520),#128,.T.);
 #520 = FACE_BOUND('',#521,.T.);
 #521 = EDGE_LOOP('',(#522,#523,#524,#525,#526));
 #522 = ORIENTED_EDGE('',*,*,#112,.F.);
 #523 = ORIENTED_EDGE('',*,*,#498,.T.);
 #524 = ORIENTED_EDGE('',*,*,#378,.T.);
 #525 = ORIENTED_EDGE('',*,*,#471,.T.);
 #526 = ORIENTED_EDGE('',*,*,#527,.F.);
 #527 = EDGE_CURVE('',#85,#449,#528,.T.);
 #528 = SURFACE_CURVE('',#529,(#533,#540),.PCURVE_S1.);
 #529 = LINE('',#530,#531);
 #530 = CARTESIAN_POINT('',(0.,200.,200.));
 #531 = VECTOR('',#532,1.);
 #532 = DIRECTION('',(1.,0.,0.));
 #533 = PCURVE('',#128,#534);
 #534 = DEFINITIONAL_REPRESENTATION('',(#535),#539);
 #535 = LINE('',#536,#537);
 #536 = CARTESIAN_POINT('',(0.,100.));
 #537 = VECTOR('',#538,1.);
 #538 = DIRECTION('',(1.,0.));
 #539 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #540 = PCURVE('',#100,#541);
 #541 = DEFINITIONAL_REPRESENTATION('',(#542),#546);
 #542 = LINE('',#543,#544);
 #543 = CARTESIAN_POINT('',(200.,0.));
 #544 = VECTOR('',#545,1.);
 #545 = DIRECTION('',(0.,1.));
 #546 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #547 = ADVANCED_FACE('',(#548),#100,.T.);
 #548 = FACE_BOUND('',#549,.T.);
 #549 = EDGE_LOOP('',(#550,#571,#572,#573));
 #550 = ORIENTED_EDGE('',*,*,#551,.F.);
 #551 = EDGE_CURVE('',#57,#426,#552,.T.);
 #552 = SURFACE_CURVE('',#553,(#557,#564),.PCURVE_S1.);
 #553 = LINE('',#554,#555);
 #554 = CARTESIAN_POINT('',(0.,200.,0.));
 #555 = VECTOR('',#556,1.);
 #556 = DIRECTION('',(1.,0.,0.));
 #557 = PCURVE('',#100,#558);
 #558 = DEFINITIONAL_REPRESENTATION('',(#559),#563);
 #559 = LINE('',#560,#561);
 #560 = CARTESIAN_POINT('',(0.,0.));
 #561 = VECTOR('',#562,1.);
 #562 = DIRECTION('',(0.,1.));
 #563 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #564 = PCURVE('',#72,#565);
 #565 = DEFINITIONAL_REPRESENTATION('',(#566),#570);
 #566 = LINE('',#567,#568);
 #567 = CARTESIAN_POINT('',(0.,200.));
 #568 = VECTOR('',#569,1.);
 #569 = DIRECTION('',(1.,0.));
 #570 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #571 = ORIENTED_EDGE('',*,*,#84,.F.);
 #572 = ORIENTED_EDGE('',*,*,#527,.T.);
 #573 = ORIENTED_EDGE('',*,*,#448,.T.);
 #574 = ADVANCED_FACE('',(#575),#72,.F.);
 #575 = FACE_BOUND('',#576,.F.);
 #576 = EDGE_LOOP('',(#577,#598,#599,#600));
 #577 = ORIENTED_EDGE('',*,*,#578,.T.);
 #578 = EDGE_CURVE('',#22,#403,#579,.T.);
 #579 = SURFACE_CURVE('',#580,(#584,#591),.PCURVE_S1.);
 #580 = LINE('',#581,#582);
 #581 = CARTESIAN_POINT('',(0.,0.,0.));
 #582 = VECTOR('',#583,1.);
 #583 = DIRECTION('',(1.,0.,0.));
 #584 = PCURVE('',#72,#585);
 #585 = DEFINITIONAL_REPRESENTATION('',(#586),#590);
 #586 = LINE('',#587,#588);
 #587 = CARTESIAN_POINT('',(0.,0.));
 #588 = VECTOR('',#589,1.);
 #589 = DIRECTION('',(1.,0.));
 #590 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #591 = PCURVE('',#44,#592);
 #592 = DEFINITIONAL_REPRESENTATION('',(#593),#597);
 #593 = LINE('',#594,#595);
 #594 = CARTESIAN_POINT('',(0.,0.));
 #595 = VECTOR('',#596,1.);
 #596 = DIRECTION('',(0.,1.));
 #597 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) 
 PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE',''
  ) );
 #598 = ORIENTED_EDGE('',*,*,#425,.F.);
 #599 = ORIENTED_EDGE('',*,*,#551,.F.);
 #600 = ORIENTED_EDGE('',*,*,#56,.T.);
 #601 = ADVANCED_FACE('',(#602),#44,.F.);
 #602 = FACE_BOUND('',#603,.F.);
 #603 = EDGE_LOOP('',(#604,#605,#606,#607,#608));
 #604 = ORIENTED_EDGE('',*,*,#578,.F.);
 #605 = ORIENTED_EDGE('',*,*,#21,.T.);
 #606 = ORIENTED_EDGE('',*,*,#198,.T.);
 #607 = ORIENTED_EDGE('',*,*,#356,.T.);
 #608 = ORIENTED_EDGE('',*,*,#402,.F.);
 #609 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) 
 GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#613)) GLOBAL_UNIT_ASSIGNED_CONTEXT
 ((#610,#611,#612)) REPRESENTATION_CONTEXT('Context #1',
  '3D Context with UNIT and UNCERTAINTY') );
 #610 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) );
 #611 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) );
 #612 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() );
 #613 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(2.E-07),#610,
  'distance_accuracy_value','confusion accuracy');
 #614 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7));
 ENDSEC;
 END-ISO-10303-21;
--- a/pruebas/catalogo/CUBE01/info.md
+++ b/pruebas/catalogo/CUBE01/info.md
@ -0,0 +1,9 @@
 # CUBE01
 Caso de prueba del profesorado. Cubo de 200 mm con un escalón en una mitad y un chaflán a 45° en la otra.
 - Escala: 1:2 (en el cajetín, campo *Title*)
 - Cotas: ninguna
 - Particularidad: planta en sistema europeo y perfil en sistema americano (mezcla intencionada)
 - Volumen esperado: 6 500 000 mm³
 - Avisos esperados: `SIN_COTAS`, `PROYECCION_MIXTA`
--- a/pruebas/catalogo/CUBE01/plano.dxf
+++ b/pruebas/catalogo/CUBE01/plano.dxf
--- a/pruebas/test_contrato.py
+++ b/pruebas/test_contrato.py
@ -0,0 +1,30 @@
 """Comprueba que motor.api cumple el contrato que usa la aplicación."""
 from pathlib import Path
 import cadquery as cq
 from motor.api import Estado, Gravedad, Resultado, exportar, procesar
 CATALOGO = Path(__file__).parent / "catalogo"
 def test_procesar_devuelve_un_resultado_valido():
    r = procesar(CATALOGO / "CUBE01" / "plano.dxf")
    assert isinstance(r, Resultado)
    assert r.estado in Estado
    assert all(a.gravedad in Gravedad for a in r.avisos)
 def test_cube01_tiene_el_volumen_esperado():
    r = procesar(CATALOGO / "CUBE01" / "plano.dxf")
    # Cubo de 200 mm menos el escalón (100^3) y el chaflán (100^3 / 2)
    assert abs(r.solido.Volume() - 6_500_000) < 1
 def test_exportar_step_y_stl(tmp_path):
    r = procesar(CATALOGO / "CUBE01" / "plano.dxf")
    for ext in (".step", ".stl"):
        exportar(r.solido, tmp_path / f"pieza{ext}")
        assert (tmp_path / f"pieza{ext}").stat().st_size > 0
    releida = cq.importers.importStep(str(tmp_path / "pieza.step")).val()
    assert releida.isValid()
--- a/pyproject.toml
+++ b/pyproject.toml
@ -0,0 +1,25 @@
 [project]
 name = "plano3d"
 version = "0.1.0"
 description = "Reconstrucción automática de piezas 3D a partir de planos técnicos 2D, con verificación del plano"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.12,<3.14"
 dependencies = [
    "cadquery>=2.8",
    "ezdxf>=1.4",
    "shapely>=2.0",
    "numpy>=2.0",
    "ortools>=9.10",
    "PySide6>=6.7",
 ]
 [dependency-groups]
 dev = [
    "pytest>=8",
    "pyinstaller>=6",
 ]
 [tool.pytest.ini_options]
 testpaths = ["pruebas"]
 pythonpath = ["."]
--- a/uv.lock
+++ b/uv.lock