AR-Shipdesign/AR_ShipDesign_prompt.md

Prompt para Claude Code — Proyecto AR-ShipDesign

Instrucciones para Álvaro (no para Code): Copia este documento ENTERO y pégalo como primer mensaje en una nueva conversación de Claude Code. Antes de pegarlo, abre Code en una carpeta neutra (no dentro de D:/AR-ShipDesign — él la usará). Si tienes Python 3.11+ instalado en Windows, mejor.

---

1. Quién eres y qué vas a construir

Eres mi co-arquitecto naval y desarrollador senior en Python. Vamos a construir AR-ShipDesign, una aplicación de escritorio para Windows que sea la herramienta de diseño naval que siempre quise tener: lo mejor de Maxsurf (rigurosidad técnica, suite de módulos integrados, transformación paramétrica) con la UX amigable de DELFTship (árbol de capas a la izquierda, vista 3D al centro, propiedades a la derecha, hidrostáticos siempre visibles abajo, wizards paso a paso).

El software debe cubrir el ciclo de diseño preliminar completo de un buque, abarcando tanto embarcaciones a motor (desplazamiento, semi-planeo, planeo) como veleros (monocascos y multicascos), e incluyendo todos los sistemas del buque: propulsión y potencia, eléctrico, combustible y lubricación, agua dulce y sanitario, lastre y achique, gobierno, contraincendios, HVAC.

Es un proyecto a largo plazo. No tienes que terminar todo en una sesión. Trabajaremos por hitos (sprints). Tu primera tarea es entender este documento, prepararme el entorno, y luego ejecutar el Sprint 0 (esqueleto del proyecto + ventana principal vacía + sistema de proyecto funcional). Después, sprint por sprint según el orden que está al final.

---

2. Ubicación del proyecto

Todo va en D:/AR-ShipDesign/.

• La carpeta ya existe vacía. Úsala.
• Si tiene contenido previo, pregúntame antes de tocar nada.
• Inicializa Git desde el primer commit. Cada sprint termina con un commit etiquetado (v0.1-sprint0, v0.2-sprint1, etc.).

---

3. Pila tecnológica

Capa	Herramienta	Por qué
Lenguaje	Python 3.11+	Ecosistema científico maduro
GUI	PySide6 (Qt 6)	Profesional, gratis (LGPL), look nativo Windows
Visualización 3D	PyVista + VTK embebido en Qt	Calidad pro sin escribir OpenGL crudo
Gráficos 2D	pyqtgraph	Más rápido que matplotlib para interactivo
NURBS / B-splines	geomdl (NURBS-Python)	Pura Python, sin dependencias compiladas
Geometría avanzada / IGES-STEP	pythonocc-core	Opcional (si está instalado), behind feature flag
Cálculo numérico	numpy, scipy	Estándar
Tabular	pandas	Estándar
Excel	openpyxl	Lectura/escritura
DXF	ezdxf	Lectura/escritura
Mallas / STL / OBJ	trimesh	Operaciones booleanas, cierre de mallas
PDF	reportlab	Reportes técnicos
Persistencia proyecto	Formato propio .arsd	ZIP con JSONs + meshes binarios
Empaquetado final	PyInstaller	.exe distribuible
Tests	pytest + benchmarks	Validación contra cascos canónicos

Reglas de implementación:

• SI estricto internamente (m, kg, s, N, Pa, W). Conversión a unidades imperiales solo en la UI cuando el usuario lo pida.
• Idioma: español por defecto, inglés como segunda opción. Strings centralizados en arshipdesign/ui/i18n/es.json y en.json.
• Type hints obligatorios en todos los módulos del core.
• Docstrings estilo NumPy con referencia bibliográfica al final cuando se implementa una fórmula del estado del arte.
• Sin red, sin telemetría, sin licencias online. El software corre offline.
• Logging con logging estándar, niveles configurables, archivo rotativo en %APPDATA%/ARShipDesign/logs/.
• Configuración del usuario vía QSettings (preferencias, recientes, idioma, tema).
• Soporta proyectos con archivos relativos (que el .arsd se pueda mover entre PCs sin romper referencias).

---

4. Estructura de carpetas del proyecto

Crea exactamente esta estructura. Cuando un módulo aún no esté implementado, crea el archivo con un docstring que diga "Stub. Implementación en Sprint X" y un raise NotImplementedError. Esto deja la navegación del proyecto coherente desde el día 1.

D:/AR-ShipDesign/
├── README.md
├── LICENSE.txt
├── CHANGELOG.md
├── pyproject.toml
├── requirements.txt
├── requirements-dev.txt
├── .gitignore
├── .env.example
├── main.py                          # entry point
│
├── arshipdesign/
│   ├── __init__.py                  # versión: __version__
│   │
│   ├── core/                        # MODELO DE DATOS (sin UI)
│   │   ├── project.py               # raíz del proyecto, serialización .arsd
│   │   ├── ship.py                  # clase Ship (raíz del modelo)
│   │   ├── hull.py                  # geometría del casco (NURBS)
│   │   ├── appendage.py             # quilla, timón, bulbo, skeg, foils
│   │   ├── superstructure.py
│   │   ├── offsets.py               # tabla de offsets
│   │   ├── waterplane.py
│   │   ├── section.py
│   │   ├── compartment.py           # bodegas, espacios secos
│   │   ├── tank.py                  # tanques con líquido
│   │   ├── liquid.py                # base de datos de líquidos
│   │   ├── weight_item.py           # ítem de peso puntual
│   │   ├── lightship.py             # peso en rosca
│   │   ├── loadcase.py              # condiciones de carga
│   │   ├── rig.py                   # aparejo del velero (mástil, jarcia, velas)
│   │   ├── sail.py                  # velas individuales (main, jib, spi…)
│   │   ├── engine.py                # motor (datos del fabricante, curva)
│   │   ├── propeller.py             # hélice
│   │   ├── gear.py                  # reductora
│   │   ├── generator.py             # genset
│   │   ├── battery.py               # banco de baterías
│   │   ├── electrical_load.py       # consumidor eléctrico
│   │   ├── pipe.py                  # tubería de un sistema
│   │   ├── valve.py
│   │   ├── pump.py
│   │   ├── system.py                # sistema del buque (combustible, fw, etc.)
│   │   └── units.py                 # conversiones SI ↔ imperial
│   │
│   ├── geometry/                    # OPERACIONES GEOMÉTRICAS
│   │   ├── nurbs_surface.py         # wrapper sobre geomdl
│   │   ├── nurbs_curve.py
│   │   ├── mesh.py                  # malla triangular para cálculos
│   │   ├── slicer.py                # corte por planos
│   │   ├── intersection.py
│   │   ├── fairing.py               # análisis de curvatura
│   │   ├── boolean.py               # operaciones booleanas con trimesh
│   │   └── fitting.py               # ajuste de NURBS a offsets
│   │
│   ├── hydrostatics/                # MOTOR DE CÁLCULO PRINCIPAL
│   │   ├── integrator.py            # Simpson 1/3, 3/8, trapezoidal, Gauss
│   │   ├── upright.py               # hidrostáticos en posición vertical
│   │   ├── heeled.py                # equilibrio escorado
│   │   ├── trim.py                  # equilibrio con asiento
│   │   ├── free_floating.py         # equilibrio libre 3DOF
│   │   ├── coefficients.py          # Cb, Cp, Cw, Cm, Cws
│   │   ├── curves_of_form.py        # las "Curvas Hidrostáticas"
│   │   └── bonjean.py               # curvas de Bonjean
│   │
│   ├── stability/
│   │   ├── intact.py                # estabilidad intacta, GZ vs heel
│   │   ├── damage.py                # estabilidad en avería
│   │   ├── criteria.py              # IMO IS Code 2008, MSC.267(85)
│   │   ├── floodable_length.py
│   │   ├── downflooding.py
│   │   └── weather.py               # criterio meteorológico
│   │
│   ├── tanks/                       # MÓDULO DE TANQUES (DELFTship-style)
│   │   ├── tank_definition.py
│   │   ├── sounding_table.py        # tablas de sondaje
│   │   ├── ullage.py                # tablas de vacío
│   │   ├── fsm.py                   # Free Surface Moment
│   │   ├── capacity_plan.py         # plan de capacidades
│   │   ├── trim_correction.py       # corrección por trim
│   │   ├── temperature_correction.py
│   │   └── tank_calibration.py
│   │
│   ├── resistance/
│   │   ├── holtrop_mennen.py        # Holtrop & Mennen 1984 (motor)
│   │   ├── savitsky.py              # planeadores
│   │   ├── van_oortmerssen.py       # embarcaciones pequeñas
│   │   ├── compton.py               # semi-planeo
│   │   ├── dsyhs.py                 # Delft Systematic Yacht Hull Series (veleros)
│   │   ├── effective_power.py       # PE = RT · V
│   │   └── added_resistance.py      # resistencia añadida en olas
│   │
│   ├── propulsion/
│   │   ├── wageningen_b.py          # Serie B Wageningen (KT, KQ, η)
│   │   ├── propeller_design.py      # diseño/selección de hélice
│   │   ├── propeller_matching.py    # matching motor-hélice
│   │   ├── cavitation.py            # criterios de cavitación (Burrill, Keller)
│   │   ├── shaft_line.py            # eje, soportes, alineación
│   │   ├── waterjet.py              # propulsión por chorro
│   │   ├── pod.py                   # propulsión azimutal
│   │   └── electric_drive.py        # propulsión eléctrica/híbrida
│   │
│   ├── engines/                     # CATÁLOGO DE MOTORES Y SELECCIÓN
│   │   ├── engine_db.py             # catálogo (datos genéricos por familia)
│   │   ├── engine_curve.py          # curva BHP vs RPM, SFOC vs carga
│   │   ├── engine_selection.py      # algoritmo de selección por potencia
│   │   ├── fuel_consumption.py      # consumo en cada modo operativo
│   │   ├── nox_emissions.py         # emisiones IMO Tier I/II/III
│   │   └── operating_profile.py     # perfil operativo (% tiempo a cada velocidad)
│   │
│   ├── sailing/                     # MÓDULO PARA VELEROS
│   │   ├── vpp.py                   # Velocity Prediction Program (núcleo)
│   │   ├── aero_model.py            # modelo aerodinámico (ORC-style)
│   │   ├── hydro_model.py           # hidrodinámica del velero (DSYHS)
│   │   ├── sail_coefficients.py     # CL, CD por tipo de vela y AWA
│   │   ├── rig_geometry.py          # geometría del aparejo
│   │   ├── stability_sailing.py     # momento adrizante, ángulo de escora
│   │   ├── polar_diagram.py         # diagrama polar de velocidad
│   │   ├── handicap_orc.py          # cálculo de rating ORC simplificado
│   │   └── multihull.py             # catamarán/trimarán específico
│   │
│   ├── seakeeping/
│   │   ├── strip_theory.py          # Salvesen-Tuck-Faltinsen
│   │   ├── rao.py                   # Response Amplitude Operators
│   │   ├── spectra.py               # ITTC, JONSWAP, Pierson-Moskowitz
│   │   ├── short_term.py            # respuestas en mar corto
│   │   ├── slamming.py              # probabilidad de pantocazo
│   │   ├── deck_wetness.py
│   │   └── motion_sickness.py       # MSI según ISO 2631
│   │
│   ├── systems/                     # SISTEMAS DEL BUQUE
│   │   ├── electrical/
│   │   │   ├── load_analysis.py     # EPLA por modo operativo
│   │   │   ├── generator_sizing.py  # selección de gensets
│   │   │   ├── battery_sizing.py    # banco de baterías
│   │   │   ├── one_line_diagram.py  # diagrama unifilar
│   │   │   ├── cable_sizing.py      # dimensionamiento de cables
│   │   │   ├── short_circuit.py     # cortocircuito básico
│   │   │   └── shore_power.py
│   │   ├── fuel/
│   │   │   ├── fuel_system.py       # diagrama, capacidades, autonomía
│   │   │   ├── autonomy.py          # cálculo de autonomía (rango)
│   │   │   ├── transfer_pumps.py
│   │   │   └── day_tank.py
│   │   ├── lub_oil/
│   │   │   └── lub_oil_system.py
│   │   ├── freshwater/
│   │   │   ├── fw_system.py         # consumo, tanques, hidróforo
│   │   │   ├── hot_water.py
│   │   │   └── watermaker.py        # osmosis inversa
│   │   ├── sanitary/
│   │   │   ├── greywater.py
│   │   │   ├── blackwater.py
│   │   │   └── stp.py               # planta de tratamiento
│   │   ├── ballast/
│   │   │   ├── ballast_system.py
│   │   │   └── ballast_pumps.py
│   │   ├── bilge/
│   │   │   ├── bilge_system.py      # achique
│   │   │   ├── oily_water_separator.py
│   │   │   └── bilge_pumps.py
│   │   ├── firefighting/
│   │   │   ├── fire_main.py         # agua salada presurizada
│   │   │   ├── foam_system.py
│   │   │   ├── co2_system.py
│   │   │   ├── sprinkler.py
│   │   │   ├── detection.py
│   │   │   └── classification.py    # zonas A60, B15, etc.
│   │   ├── hvac/
│   │   │   ├── heat_balance.py      # cargas térmicas por espacio
│   │   │   ├── duct_sizing.py
│   │   │   ├── chiller_sizing.py
│   │   │   └── ventilation.py
│   │   ├── steering/
│   │   │   ├── rudder_design.py     # área, perfil, fuerza
│   │   │   ├── steering_gear.py     # potencia del servo
│   │   │   └── thrusters.py         # impulsores transversales
│   │   ├── anchoring/
│   │   │   ├── anchor_selection.py
│   │   │   ├── chain_locker.py
│   │   │   └── windlass.py
│   │   └── compressed_air/
│   │       └── compressed_air.py
│   │
│   ├── io/                          # IMPORT / EXPORT
│   │   ├── offsets_csv.py
│   │   ├── offsets_excel.py
│   │   ├── dxf_reader.py
│   │   ├── dxf_writer.py
│   │   ├── iges_reader.py           # con pythonocc, opcional
│   │   ├── iges_writer.py
│   │   ├── step_io.py
│   │   ├── stl_export.py
│   │   ├── obj_export.py
│   │   ├── rhino_3dm.py             # opcional (rhino3dm-py)
│   │   ├── delftship_fbm.py         # importar .fbm de DELFTship
│   │   ├── maxsurf_msd.py           # importar .msd si es posible (puede ser parcial)
│   │   ├── project_serializer.py    # formato .arsd
│   │   └── pdf_export.py
│   │
│   ├── parametric/                  # GENERACIÓN PARAMÉTRICA
│   │   ├── wizard_workboat.py       # casco con espejo
│   │   ├── wizard_cruiser.py        # crucero a motor
│   │   ├── wizard_sailing_mono.py   # velero monocasco
│   │   ├── wizard_sailing_cat.py    # catamarán
│   │   ├── wizard_planing.py        # planeador
│   │   ├── series60.py              # generador serie 60
│   │   ├── wigley.py                # casco matemático Wigley
│   │   ├── kcs.py                   # KRISO Container Ship
│   │   ├── dtmb5415.py              # DTMB 5415 (caso militar)
│   │   └── lackenby_transform.py    # transformación paramétrica
│   │
│   ├── reports/
│   │   ├── hydrostatic_report.py
│   │   ├── stability_booklet.py     # booklet completo
│   │   ├── capacity_plan_report.py
│   │   ├── lines_plan.py            # plano de líneas (PDF y DXF)
│   │   ├── general_arrangement.py   # plano de disposición general
│   │   ├── resistance_powering.py
│   │   ├── electrical_balance.py    # balance eléctrico
│   │   ├── system_diagrams.py       # P&IDs simplificados
│   │   ├── vpp_report.py            # polar diagram + tabla para velero
│   │   └── pdf_builder.py           # constructor común
│   │
│   ├── ui/                          # TODA LA UI Qt
│   │   ├── main_window.py
│   │   ├── i18n/
│   │   │   ├── es.json
│   │   │   └── en.json
│   │   ├── themes/
│   │   │   ├── light.qss
│   │   │   └── dark.qss
│   │   ├── icons/                   # SVG
│   │   ├── widgets/
│   │   │   ├── viewer_3d.py
│   │   │   ├── viewer_lines.py      # plano de líneas 2D
│   │   │   ├── viewer_polar.py      # polar diagram velero
│   │   │   ├── tree_panel.py
│   │   │   ├── properties_panel.py
│   │   │   ├── hydrostatics_panel.py  # panel fijo abajo, siempre visible
│   │   │   ├── offsets_editor.py
│   │   │   ├── tank_editor.py
│   │   │   ├── loadcase_editor.py
│   │   │   ├── rig_editor.py
│   │   │   ├── engine_picker.py
│   │   │   ├── propeller_designer.py
│   │   │   ├── electrical_load_table.py
│   │   │   ├── system_diagram_canvas.py  # canvas para diagramas unifilares y P&ID
│   │   │   └── curve_plotter.py
│   │   ├── dialogs/
│   │   │   ├── new_project.py
│   │   │   ├── wizards.py
│   │   │   ├── stability_criteria_picker.py
│   │   │   ├── liquid_picker.py
│   │   │   ├── preferences.py
│   │   │   └── about.py
│   │   ├── commands/                # patrón Command para Undo/Redo
│   │   │   ├── command.py
│   │   │   ├── modify_hull.py
│   │   │   ├── add_tank.py
│   │   │   └── ...
│   │   └── shortcuts.py             # atajos de teclado centralizados
│   │
│   └── utils/
│       ├── logger.py
│       ├── settings.py
│       ├── async_runner.py          # QThreadPool para cálculos largos
│       └── validation.py
│
├── data/
│   ├── liquids.json
│   ├── stability_criteria.json
│   ├── engine_catalog.json          # catálogo genérico de motores
│   ├── propeller_series/
│   │   └── wageningen_b.json
│   ├── steel_grades.json
│   ├── benchmarks/                  # cascos de validación
│   │   ├── wigley_hull.csv
│   │   ├── series60_cb070.csv
│   │   ├── kcs.csv
│   │   ├── dtmb5415.csv
│   │   ├── delft_372.csv            # Delft Systematic Yacht Series
│   │   └── README.md
│   ├── icons_class/                 # iconos para diagramas (bombas, válvulas, etc.)
│   └── templates/
│       ├── lightship_workboat.json
│       ├── lightship_yacht.json
│       └── default_loadcases.json
│
├── tests/
│   ├── conftest.py
│   ├── test_integrator.py
│   ├── test_hydrostatics_wigley.py
│   ├── test_hydrostatics_series60.py
│   ├── test_gz_curve_imo.py
│   ├── test_holtrop.py
│   ├── test_savitsky.py
│   ├── test_dsyhs.py
│   ├── test_vpp.py
│   ├── test_tank_calculations.py
│   ├── test_capacity_plan.py
│   ├── test_offsets_io.py
│   ├── test_dxf_io.py
│   ├── test_project_serialization.py
│   ├── test_propeller_matching.py
│   ├── test_electrical_load.py
│   └── test_engine_selection.py
│
└── docs/
    ├── user_manual.md
    ├── theory_manual.md             # FÓRMULAS + REFERENCIAS BIBLIOGRÁFICAS
    ├── validation_report.md         # validación contra cascos canónicos
    ├── developer_guide.md
    └── changelog_internal.md

---

5. Layout de la ventana principal (UX inspirada en DELFTship)

┌──────────────────────────────────────────────────────────────────────────┐
│ Archivo | Editar | Ver | Modelo | Análisis | Sistemas | Reportes | Ayuda │
├──────────────────────────────────────────────────────────────────────────┤
│ 🗎  💾  ↩  ↪  | 🔍 🚢 wizard | ⚙ unidades | ☀/🌙 tema | español ▾       │
├────────────┬──────────────────────────────────────┬──────────────────────┤
│            │                                      │                      │
│ 📁 Project │                                      │ Propiedades del      │
│  ▾ Ship    │                                      │ ítem seleccionado    │
│   ▾ Casco  │                                      │                      │
│    Surf 1  │     Vista 3D principal (PyVista)     │ Loa  : 24.50 m       │
│    Surf 2  │                                      │ Lpp  : 23.40 m       │
│   ▾ Apend. │     • orbit / zoom / pan             │ B    :  6.00 m       │
│    Quilla  │     • toggle waterlines              │ T    :  3.20 m       │
│    Timón   │     • toggle sections                │ D    :  3.80 m       │
│   ▾ Tanques│     • shaded / wireframe / hidden    │ ...                  │
│    FO 1 P  │     • measure tool                   │                      │
│    FO 1 S  │     • clipping plane                 │                      │
│    FW 1    │                                      │                      │
│   ▾ Bodeg. │                                      │                      │
│   ▾ Casos  │                                      │                      │
│    Light   │                                      │                      │
│    Full    │                                      │                      │
│    Ballast │                                      │                      │
│   ▾ Aparejo│                                      │                      │
│    Mástil  │                                      │                      │
│    Mayor   │                                      │                      │
│   ▾ Motor  │                                      │                      │
│   ▾ Sist.  │                                      │                      │
│    Eléct.  │                                      │                      │
│    Combust │                                      │                      │
│    F.W.    │                                      │                      │
│    Achique │                                      │                      │
│    Lastre  │                                      │                      │
│    CI      │                                      │                      │
│    HVAC    │                                      │                      │
├────────────┴──────────────────────────────────────┴──────────────────────┤
│ HIDROSTÁTICOS EN VIVO (siempre visible):                                  │
│ T=[3.20 m ▾]  Δ=2845 t  LCB=12.30  KB=1.85  KMT=4.20  GMT=1.05           │
│ TPC=8.2 t/cm  MCT=42.5  Cb=0.682  Cw=0.821  Cm=0.985  ⚠ IMO OK           │
├──────────────────────────────────────────────────────────────────────────┤
│ Tabs: [3D] [Líneas] [Offsets] [Curvas] [Tanques] [Capacidad]              │
│       [Estabilidad GZ] [Resistencia] [Propulsión] [VPP] [Movimientos]    │
│       [Eléctrico] [Combustible] [F.W.] [Achique] [CI] [HVAC] [Reporte]   │
└──────────────────────────────────────────────────────────────────────────┘

Reglas de UX irrenunciables:

1. Auto-recálculo del panel hidrostático en <200 ms al cambiar el calado o el modelo.
2. Undo/Redo robusto (Ctrl+Z hasta 50 pasos, historial visible).
3. Unidades configurables en UI, SI internamente.
4. Tooltips con la fórmula en hover de cualquier campo calculado (p.ej. KMT → "KMT = KB + IT/∇").
5. Drag & drop de offsets, IGES, DXF sobre la ventana.
6. Wizards paso a paso para cada tipo de embarcación.
7. Validación visual del modelo: panel rojo con problemas concretos + botón "intentar corregir".
8. Hidrostáticos en vivo abajo, siempre visible, no se puede ocultar (en lateral si la pantalla es chica).
9. Indicador "⚠ IMO" en verde/amarillo/rojo según cumplimiento del último caso de carga activo.

---

6. Módulo HIDROSTÁTICOS (el motor que alimenta todo)

Para cualquier calado/asiento/escora, sobre la malla triangular del casco con regla de Simpson 1/3 (fallback 3/8 cuando estaciones no son impares, trapezoidal para mallas irregulares):

Símbolo	Nombre	Fórmula
∇	Volumen desplazado	∫∫∫ dV
Δ	Desplazamiento	ρ · ∇
Aw	Área del plano de flotación	∫∫ dA en z=T
Cw	Coef. plano flotación	Aw / (Lwl · B)
Am	Área cuaderna maestra	∫ y dz en x=Lpp/2
Cm	Coef. cuaderna maestra	Am / (B · T)
Cb	Coef. de bloque	∇ / (Lwl · B · T)
Cp	Coef. prismático	Cb / Cm
S	Superficie mojada	∫∫ dS
LCB	Centro long. carena	∫∫∫ x dV / ∇
KB (VCB)	Centro vert. carena	∫∫∫ z dV / ∇
LCF	Centro long. flotación	∫∫ x dA / Aw
IT	Inercia transv. de Aw	∫∫ y² dA
IL	Inercia long. de Aw	∫∫ (x−xF)² dA
BMT	Radio metac. transv.	IT / ∇
BML	Radio metac. long.	IL / ∇
KMT	Altura metac. transv.	KB + BMT
KML	Altura metac. long.	KB + BML
TPC	Toneladas por cm inmersión	Aw · ρ / 100
MCT (MTC)	Momento para cambiar asiento 1 cm	Δ · GML / (100 · Lpp)
WSA	Wetted Surface Area	S
Cws	Coef. superficie mojada	S / √(∇ · Lwl)

Salidas obligatorias del módulo:

• Curvas de Forma (los 12-15 parámetros vs calado en una gráfica multi-escala).
• Curvas de Bonjean (área seccional vs calado, por estación).
• Resolutor de equilibrio libre 3 GDL (heave + trim + heel) con scipy.optimize.fsolve o Newton-Raphson, tolerancia configurable.

---

7. Estabilidad y curva GZ

• GZ vs escora de 0° a 90° en pasos de 5° (configurable). En cada ángulo: mantener Δ constante, reequilibrar trim, calcular B', GZ = brazo horizontal G→vertical de B'.
• Salidas: curva GZ, GZmax y ángulo, rango de estabilidad positiva, ángulo de inundación progresiva, área bajo curva.
• Criterios IMO IS Code 2008 (MSC.267(85)):
  • A(0→30°) ≥ 0.055 m·rad
  • A(0→40°) ≥ 0.090 m·rad
  • A(30→40°) ≥ 0.030 m·rad
  • GZ(30°) ≥ 0.20 m
  • Ángulo de GZmax ≥ 25°
  • GMT inicial ≥ 0.15 m
• Criterio meteorológico A.749(18).
• Criterios extra: USCG, ABS, RINA — configurables en data/stability_criteria.json.
• Estabilidad en avería (determinística): por compartimento, permeabilidad configurable, método de pérdida de flotabilidad.
• Floodable length curve.

---

8. TANQUES (lo bueno de DELFTship)

Esta es la parte donde el software gratuito típicamente flojea. Hacerla bien.

8.1 Definición de tanque

• Geometría:
  • Prismático (6 planos): caso fácil.
  • Con forma de casco (límite exterior = superficie del casco): wing tanks, double bottom.
  • Arbitrario (malla triangular cerrada): casos complejos.
• Tipo: HFO, MGO, LO, FW, SW lastre, agua gris, agua negra, sentina, carga líquida, vacío.
• Líquido desde data/liquids.json (ver §8.4), override permitido.
• Capacidad 100% (volumen geométrico calculado).
• Capacidad operativa (98% combustibles, 95% agua, 100% carga estiba).
• Nivel actual (intercambiable: % / m³ / t / sondaje).
• Posición de boca de medición (para que las tablas de sondaje reflejen el sensor real).
• Permeabilidad (avería): 0.95 líquidos, 0.85 carga seca, 0.95 máquinas, 0.60 acomodación.

8.2 Cálculos por tanque

1. Tabla de sondaje: cada cm (config) desde el fondo: V, peso, LCG, TCG, VCG del contenido, FSM, IT del líquido.
2. Tabla de ullage (equivalente desde el techo).
3. Curva de FSM vs nivel.
4. Corrección por trim (las tablas dependen del asiento).
5. Corrección por temperatura (para combustibles, expansión).
6. Validación: detección de intersecciones entre tanques, tanques fuera del casco, mal cerrados.

8.3 Integración con estabilidad

En cada LoadCase:

• Sumar pesos (lightship + cargas + líquidos).
• Calcular LCG/TCG/VCG combinado.
• GG' (corrección FSM) = Σ(FSMi · ρi) / Δ.
• GMT corregido = GMT − GG'.
• Reportar equilibrio + estabilidad + cumplimiento criterios.

8.4 data/liquids.json precarga

{
  "HFO":  {"name": "Heavy Fuel Oil",       "density_kg_m3": 991,  "viscosity_cSt": 380},
  "MGO":  {"name": "Marine Gas Oil",       "density_kg_m3": 890,  "viscosity_cSt": 6},
  "MDO":  {"name": "Marine Diesel Oil",    "density_kg_m3": 870,  "viscosity_cSt": 11},
  "LSFO": {"name": "Low Sulphur Fuel Oil", "density_kg_m3": 985,  "viscosity_cSt": 180},
  "LO":   {"name": "Lubricating Oil",      "density_kg_m3": 920,  "viscosity_cSt": 100},
  "HO":   {"name": "Hydraulic Oil",        "density_kg_m3": 875,  "viscosity_cSt": 46},
  "FW":   {"name": "Fresh Water",          "density_kg_m3": 1000, "viscosity_cSt": 1.0},
  "SW":   {"name": "Sea Water (ballast)",  "density_kg_m3": 1025, "viscosity_cSt": 1.05},
  "DW":   {"name": "Distilled Water",      "density_kg_m3": 999,  "viscosity_cSt": 1.0},
  "SLP":  {"name": "Slop / Bilge",         "density_kg_m3": 1010, "viscosity_cSt": 5},
  "SEW":  {"name": "Sewage",               "density_kg_m3": 1010, "viscosity_cSt": 3},
  "URE":  {"name": "Urea 40% (SCR)",       "density_kg_m3": 1090, "viscosity_cSt": 1.4}
}

---

9. RESISTENCIA — múltiples métodos según tipo de buque

Selección automática del método según parámetros (con override manual):

Método	Aplicabilidad
Holtrop & Mennen 1984	Cascos de desplazamiento convencionales, 0.05 < Fr < 0.45
Van Oortmerssen 1971	Embarcaciones pequeñas Lwl 8–80 m, desplazamiento
Compton 1986	Semi-planeo 0.4 < Fr < 0.9
Savitsky 1964	Planeadores prismáticos, Fr_∇ > 1.0
Delft Systematic Yacht Hull Series (DSYHS)	Veleros (Keuning–Sonnenberg)
Mercier–Savitsky	Round bilge planing

9.1 Holtrop & Mennen 1984 (detalle obligatorio)

Implementar con todos los componentes:

• RF (ITTC-57): CF = 0.075 / (log₁₀ Rn − 2)²
• (1+k) factor de forma (fórmula de Holtrop, c14)
• RAPP apéndices (con factores 1+k2 por apéndice)
• RW olas (con c1…c17 según Fr y Cp)
• RB bulbo de proa
• RTR espejo de popa
• RA corrección modelo-buque (CA)
• RT = (1+k)·RF + RAPP + RW + RB + RTR + RA
• PE = RT · V

Inputs derivados automáticamente del modelo: L, B, T, Cb, Cp, Cm, Cw, ∇, S, LCB%, AT (transom), ABT y hB (bulbo).

Salida: curva RT y PE vs V (Fr 0.05 → 0.45 o rango definido).

Referencia: Holtrop J., 1984, "A statistical re-analysis of resistance and propulsion data", ISP Vol. 31.

9.2 DSYHS (veleros)

Para veleros usar la regresión de Delft (Keuning–Sonnenberg 1998 y actualizaciones):

• Resistencia residual del casco desnudo (upright).
• Incremento por escora (heel drag).
• Resistencia inducida por sideforce (apéndices).
• Resistencia añadida en olas.

Parámetros geométricos requeridos: Lwl, Bwl, Tc (canoe body), ∇c, LCB%, LCF%, Cp, Aw, S, BTR (beam-to-draft ratio).

---

10. PROPULSIÓN

10.1 Serie B Wageningen

Implementar coeficientes KT, KQ vs J para:

• Número de palas Z = 2, 3, 4, 5, 6, 7
• Relación área expandida/disco AE/A0 = 0.30 → 1.05
• Relación paso/diámetro P/D = 0.5 → 1.4

Fórmulas polinómicas Oosterveld–van Oossanen (con corrección de Reynolds).

10.2 Matching motor-hélice

Algoritmo:

1. Dado RT(V) y selección de hélice (D, P/D, AE/A0, Z).
2. Calcular wake fraction w y thrust deduction t (Holtrop).
3. Resolver punto de operación: T(1−t) = RT, encontrar n (rpm de hélice).
4. Calcular Q, PD (delivered power), aplicar eficiencias (η_S eje, η_R relativo rotacional, η_G reductora).
5. PB (brake power) = PD / (η_S · η_G).
6. Comparar con curva del motor a ese rpm.

Salida: punto de operación óptimo, curvas de KT, KQ, η, demanda vs disponible.

10.3 Cavitación

• Criterio de Burrill (gráfico σ vs τc).
• Criterio de Keller (mínimo AE/A0 para evitar cavitación).
• Alerta visual cuando el diseño viola alguno.

10.4 Otros propulsores

• Waterjet: cálculo simplificado de empuje vs caudal y velocidad.
• Pod azimutal: con factor de degradación frente a hélice convencional.
• Propulsión eléctrica/híbrida: cálculo de potencia eléctrica requerida, factor de carga, eficiencia de motor eléctrico, gestión de batería.

---

11. MOTORES y dimensionamiento

11.1 Catálogo data/engine_catalog.json

Catálogo genérico por familia (no fabricante específico para evitar IP). Datos típicos:

{
  "high_speed_diesel": {
    "rpm_range": [1500, 2400],
    "bhp_range_kw": [50, 1500],
    "sfoc_at_85_kw_kwh": 215,
    "weight_kg_per_kw": 3.5,
    "applications": ["yates", "workboats", "patrulleras"]
  },
  "medium_speed_diesel": {
    "rpm_range": [600, 1200],
    "bhp_range_kw": [500, 8000],
    "sfoc_at_85_kw_kwh": 195,
    "weight_kg_per_kw": 12,
    "applications": ["ferries", "OSV", "cargo pequeño"]
  },
  "low_speed_two_stroke": {
    "rpm_range": [70, 180],
    "bhp_range_kw": [3000, 80000],
    "sfoc_at_85_kw_kwh": 165,
    "weight_kg_per_kw": 38,
    "applications": ["bulk carrier", "tanker", "container"]
  },
  "outboard_petrol": {...},
  "outboard_electric": {...},
  "gas_turbine": {...},
  "dual_fuel": {...},
  "fuel_cell_h2": {...}
}

11.2 Algoritmo de selección

Inputs: PB requerida al MCR, velocidad de servicio, perfil operativo (% del tiempo a cada V).

Salida ranked:

1. Familia recomendada.
2. Cantidad de motores (1, 2, 4).
3. Rango de rpm óptimo para matching con hélice.
4. SFOC promedio sobre el perfil operativo → consumo en t/día y rango / autonomía.
5. Peso seco estimado.

11.3 Curva de consumo

SFOC vs % carga del motor (curva en U típica con mínimo cerca del 80%). Salidas:

• Consumo en cada modo (en puerto, maniobra, navegación, full ahead).
• Autonomía: rango_nm = (capacidad_FO · 1000 / consumo_horario · ηtransfer) · V_servicio
• CO₂ emitido por viaje (factor 3.114 kg CO₂ / kg HFO).
• NOx: comparación con límite IMO Tier I/II/III según año y zona.

---

12. VELEROS — Módulo VPP completo

12.1 Arquitectura del VPP

Sigue el esquema clásico (ORC y Maxsurf VPP):

Loop de equilibrio para cada (TWS, TWA):

1. Estimar velocidad inicial Vboat.
2. Calcular AWA y AWS (viento aparente) a partir de TWS, TWA, Vboat.
3. Modelo aerodinámico → fuerza propulsiva, fuerza lateral (heeling force), momento escorante.
4. Modelo hidrodinámico → resistencia total (upright + heel + induced + added wave) y sideforce de apéndices.
5. Balance de fuerzas:
   • ΣFlongitudinal = 0 → F_drive = R_total
   • ΣFlateral = 0 → F_side_sails = F_side_apéndices (define leeway angle β)
   • ΣMroll = 0 → Heeling moment = Righting moment (define φ ángulo de escora)
6. Si no balancea, ajustar Vboat y volver al paso 2.
7. Para optimizar VMG, iterar también sobre reef (rizado) y flat (planitud de vela).

12.2 Modelo aerodinámico (estilo ORC)

Coeficientes CL y CD por tipo de vela vs AWA:

• Main + jib (upwind)
• Main + genoa
• Main + spinnaker (downwind asimétrico)
• Main + code zero

Cada vela: Cl_max, Cd_min, curvas tabuladas. Compatible con la documentación pública del ORC VPP 2023.

Escalado con altura del centro de esfuerzo (CE), corrección por gradiente de viento (perfil logarítmico atmosférico).

12.3 Modelo hidrodinámico

• DSYHS (Keuning–Sonnenberg) para resistencia upright del canoe body.
• Heel drag por incremento de WSA y cambio de forma de carena al escorar.
• Induced drag del keel y timón (teoría de Glauert).
• Added wave resistance (regresión de Gerritsma).

12.4 Estabilidad del velero

Momento adrizante con corrección por:

• Velocidad (loss of stability with speed).
• Movimiento de tripulación (crew on rail).
• Vela arrizada / flat factor.

12.5 Salidas

• Polar diagram interactivo (TWA radial, V boat radial, TWS curvas).
• Tabla de velocidades TWS × TWA (igual que ORC).
• VMG upwind y downwind con TWA óptimo.
• Curvas de target speed para regata.
• Rating ORC simplificado (estimación, no certificado).

12.6 Multicascos

Catamarán/trimarán: balance lateral diferente (no escora, levanta casco a barlovento). Hidrodinámica por casco individual + interferencia. Momento de vuelco (capsize moment) en lugar de adrizamiento.

---

13. SEAKEEPING (predicción de movimientos)

Strip theory Salvesen–Tuck–Faltinsen (1970) para los 6 GDL.

Outputs:

• RAOs por modo, vs ω y rumbo respecto a olas.
• Espectros: ITTC, Pierson–Moskowitz, JONSWAP (parametrizable Hs, Tp, γ).
• Respuestas a corto plazo: significant motion, máximo esperado en N ciclos.
• Probabilidad de slamming, deck wetness, propeller emergence.
• MSI (Motion Sickness Incidence) según ISO 2631.
• Gráficas polares de movimientos vs rumbo.

---

14. SISTEMAS DEL BUQUE

Cada sistema tiene su propia tab en la UI, su propio modelo de datos en core/, su propio motor de cálculo en systems/, y su propio reporte en reports/.

14.1 Sistema ELÉCTRICO

Electrical Power Load Analysis (EPLA) clásico:

• Lista de consumidores eléctricos (luces, bombas, motores auxiliares, electrónica, HVAC, cocina, etc.) con:
  • Potencia conectada (kW)
  • Tensión (24V DC / 230V AC / 400V AC / 690V AC)
  • Factor de carga (LF) por modo operativo
  • Factor de simultaneidad
• Modos operativos configurables:
  • En puerto, sin carga
  • En puerto, cargando/descargando
  • Maniobra
  • Navegación normal
  • Navegación con mal tiempo
  • Emergencia
• Cálculo automático por modo: ΣP · LF · KS = demanda eléctrica del modo.
• Selección de generadores: número, potencia, redundancia (uno fuera de servicio debe cubrir el modo crítico).
• Banco de baterías (yates, eléctricos): capacidad Ah, autonomía a hotel load, recarga.
• Diagrama unifilar dibujado en canvas Qt: barras principal/emergencia, breakers, transformadores, consumidores agrupados.
• Cable sizing simplificado por corriente de carga, longitud y caída de tensión (≤3% en main, ≤1% en lighting).
• Cortocircuito básico (Icc en barras principales).
• Reporte "Electrical Load Balance" estilo clasificadora.

14.2 Sistema de COMBUSTIBLE

• Tanques de almacenamiento + tanque de servicio diario (day tank) + tanque de sedimentación.
• Bombas de trasiego (capacidad mínima: llenar day tank en 30 min).
• Separadoras (purificadoras) — capacidad según caudal de motor + margen.
• Tubería con diámetros calculados por velocidad de fluido (~1 m/s succión, ~2 m/s descarga).
• Autonomía: con perfil operativo y consumo de motor → días de navegación, rango en mn.
• Diagrama P&ID simplificado.

14.3 Sistema de LUBRICACIÓN

• Carter del motor + tanque de almacenamiento + tanque de lodos.
• Bomba de lubricación, enfriador, filtros.
• Cálculo de tiempo entre cambios según horas de operación.

14.4 Sistema de AGUA DULCE

• Consumo per cápita: 120-200 L/persona/día (configurable según tipo de buque).
• Tanques + hidróforo + calentador.
• Watermaker (osmosis inversa): caudal vs consumo + margen, energía consumida (~3-4 kWh/m³).
• Dimensionamiento de tanques para autonomía con/sin watermaker.

14.5 Sistema SANITARIO (aguas grises y negras)

• Tanques de retención (capacidad mínima según MARPOL Anexo IV).
• STP (Sewage Treatment Plant) o tanque de retención + descarga en puerto.
• Conexiones a tierra.

14.6 Sistema de LASTRE

• Tanques de lastre + bombas de lastre.
• Diagrama de lastre para transición entre casos de carga.
• Cumplimiento Ballast Water Management Convention (D-1/D-2) — solo nota informativa.

14.7 Sistema de ACHIQUE (BILGE)

• Bomba principal + emergencia.
• Capacidad mínima según clasificadora (típico: vaciar el compartimento más grande en 2 horas).
• Separador de sentinas (OWS) — 15 ppm IMO.
• Diagrama de tuberías por compartimento.

14.8 Sistema CONTRAINCENDIOS

• Fire main (agua salada presurizada): bombas principales + emergencia, hidrantes, mangueras, lanzas, presión mínima en hidrante más alejado (típico 3.5 bar).
• Sistema fijo: CO₂ para cámara de máquinas (5-7% volumen), espuma para tanques de combustible.
• Sprinklers en acomodaciones (clase B).
• Detección: humo, calor, llama; zonas A60/A30/B15.
• Esquema de clasificación de mamparos por zona.
• Cálculo: capacidad de bomba CI = mínimo 2 chorros simultáneos en hidrante más desfavorable.

14.9 Sistema HVAC

• Heat balance por espacio: cargas sensibles + latentes + ganancia/pérdida por mamparos.
• Condiciones ambientales: ASHRAE (verano 35°C/27°C húmedo, invierno -10°C) — configurables.
• Caudal de aire por espacio (renovaciones/hora según uso).
• Dimensionamiento de chiller: kW frigoríficos + margen 15%.
• Ductos: velocidades 4-6 m/s en main, 2-3 m/s en ramificaciones.
• Reporte de cargas por compartimento.

14.10 Sistema de GOBIERNO

• Diseño del timón: área (regla típica A_R = c · L · T donde c = 1.5–2.5% para mercante, 4-6% para velero).
• Fuerza en el timón a velocidad máxima (fórmula de Joessel modificada).
• Steering gear: torque requerido, potencia hidráulica, tiempo de banda-a-banda (≤28 s a max ahead según SOLAS).
• Thrusters transversales: empuje requerido para vientos cruzados típicos.

---

15. IMPORTACIÓN / EXPORTACIÓN

15.1 Tabla de offsets

Aceptar CSV/Excel en dos formatos:

1. Largo (3 columnas: Station, Waterline, HalfBreadth).
2. Matricial (filas = estaciones, columnas = WL, celdas = semi-mangas).

Wizard: previsualización con detección automática del formato; si falla, asistente paso a paso.

Ajustar superficies NURBS por mínimos cuadrados con geomdl.fitting.approximate_surface.

15.2 Otros formatos

• IGES: lectura/escritura con pythonocc-core (opcional).
• STEP: lectura/escritura idem.
• DXF: polylines 3D que representan WL/sections/buttocks → reconstrucción por skinning.
• STL/OBJ: malla triangular (export para CFD externo o impresión).
• Rhino 3DM: con rhino3dm-py (opcional).
• DELFTship .fbm: lectura best-effort (formato binario propio).
• Maxsurf .msd: lectura parcial best-effort.

15.3 Wizards paramétricos

• Casco con espejo (workboat).
• Crucero a motor (yate de desplazamiento).
• Planeador (semi-V, hard chine).
• Velero monocasco moderno.
• Catamarán.
• Serie 60 (Cb objetivo).
• Wigley (validación).
• DTMB 5415 (validación militar).

15.4 Exportación

• DXF 2D (plano de líneas con cajetín, escala, cotas, estilo astillero).
• DXF 3D (wireframe).
• IGES, STEP, STL, OBJ, CSV.
• PDF de reportes.

---

16. CASOS DE CARGA (LoadCase)

Cada LoadCase agrega:

• Lightship: peso en rosca con LCG/TCG/VCG, radios de giro (kxx, kyy, kzz).
• Deadweight items: lista de pesos (tripulación, provisiones, equipo, stores) con posición.
• Cargo: bodegas con peso y CG o densidad y nivel.
• Tanques: nivel de cada uno.
• Trim correctors / constants.

Motor → equilibrio + reporte:

• Calado en proa, popa, medio, en perpendiculares.
• Trim, heel.
• Δ, GMT, GMT corregido por FSM.
• Reserva de flotabilidad.
• Cumplimiento criterios IMO (verde/amarillo/rojo).

Plantillas predefinidas: Lightship, Departure full, Arrival full, Departure ballast, Arrival ballast.

---

17. VALIDACIÓN CONTRA BENCHMARKS

Antes de marcar un módulo como completo, validar contra cascos con valores publicados:

Casco	Origen	Validar
Wigley	Casco matemático	∇, S, Cb, Cp analíticos
Series 60 Cb 0.70	Todd 1963	Hidrostáticos + Holtrop
KCS (KRISO Container Ship)	Tokyo 2015 workshop	Holtrop + CFD ref
DTMB 5415	Combatant naval	Hidrostáticos + seakeeping
Delft 372	DSYHS (velero)	Resistencia upright + heel

Cada test guarda el resultado en tests/benchmark_results/ y compara con tolerancia (±2% típicamente).

---

18. PLAN DE SPRINTS (ejecuta en este orden)

Cada sprint termina con: tests pasando, commit etiquetado, entrada en CHANGELOG.md, sección añadida a docs/user_manual.md.

Sprint 0 — Setup (esta sesión, esperable 1-2 horas)

• Crear estructura completa de carpetas con stubs.
• pyproject.toml, requirements.txt, .gitignore, LICENSE (MIT por defecto, pregúntame si quieres otra).
• main.py que abra una ventana Qt vacía con menú base.
• core/project.py con clase Project y serialización .arsd (vacía pero funcional).
• core/units.py con conversiones SI ↔ imperial.
• ui/main_window.py con el layout descrito en §5 (paneles vacíos pero presentes).
• tests/conftest.py y un test trivial que valide que arranca.
• Git init + primer commit v0.1-sprint0.
• Entregable: la app abre, se ve el layout, archivo nuevo / guardar / abrir funcionan con .arsd vacío.

Sprint 1 — Geometría y offsets

• geometry/nurbs_surface.py, geometry/mesh.py, geometry/slicer.py.
• io/offsets_csv.py, io/offsets_excel.py.
• ui/widgets/offsets_editor.py, ui/widgets/viewer_3d.py.
• Wizard Wigley (caso de validación inmediata).
• Entregable: cargar tabla de offsets, ver casco en 3D, ver waterlines/sections.

Sprint 2 — Hidrostáticos básicos

• hydrostatics/integrator.py (Simpson 1/3, 3/8, trap).
• hydrostatics/upright.py, coefficients.py, curves_of_form.py.
• ui/widgets/hydrostatics_panel.py (panel inferior siempre visible).
• Tests contra Wigley analítico y Series 60.
• Entregable: panel hidrostático abajo recalcula al cambiar calado.

Sprint 3 — Equilibrio libre y estabilidad GZ

• hydrostatics/free_floating.py, heeled.py, trim.py.
• stability/intact.py, criteria.py.
• ui/widgets/curve_plotter.py (pyqtgraph).
• Entregable: curva GZ + cumplimiento IMO con semáforo.

Sprint 4 — Tanques completo

• core/tank.py, core/liquid.py.
• tanks/* (todos los módulos).
• ui/widgets/tank_editor.py.
• core/loadcase.py + integración con estabilidad.
• Entregable: definir tanques, generar tablas de sondaje, ver capacity plan, estabilidad con FSM.

Sprint 5 — Resistencia y propulsión

• resistance/holtrop_mennen.py, savitsky.py, van_oortmerssen.py.
• propulsion/wageningen_b.py, propeller_matching.py.
• engines/engine_db.py, engine_selection.py.
• Entregable: curva RT/V, selección hélice, selección motor con consumo.

Sprint 6 — Veleros y VPP

• core/rig.py, core/sail.py.
• sailing/vpp.py, aero_model.py, hydro_model.py.
• resistance/dsyhs.py.
• ui/widgets/viewer_polar.py.
• Entregable: polar diagram completo, tabla de velocidades estilo ORC.

Sprint 7 — Sistemas del buque

• systems/electrical/* con EPLA y diagrama unifilar.
• systems/fuel/* con autonomía.
• systems/freshwater/*, bilge/*, ballast/*.
• ui/widgets/system_diagram_canvas.py.
• Entregable: balance eléctrico completo, autonomía calculada, diagramas básicos.

Sprint 8 — CI, HVAC, gobierno

• systems/firefighting/*, hvac/*, steering/*, anchoring/*.
• Entregable: dimensionamiento de timón, servo, CI, HVAC.

Sprint 9 — Seakeeping

• seakeeping/strip_theory.py, rao.py, spectra.py.
• Entregable: RAOs, espectros, MSI.

Sprint 10 — Reportes profesionales

• Todos los reports/* con plantillas PDF estilo astillero.
• Stability Booklet completo.
• Capacity Plan.
• Lines Plan en PDF y DXF.

Sprint 11 — IGES/STEP, paramétricos avanzados

• io/iges_*, step_io.py con pythonocc.
• parametric/lackenby_transform.py.
• Wizards completos para todos los tipos.

Sprint 12 — Empaquetado y distribución

• PyInstaller config para .exe.
• Splash screen, icono, installer (NSIS).
• Manual de usuario PDF.

---

19. REGLAS DE TRABAJO ENTRE TÚ Y YO

1. Antes de cada sprint, resúmeme en 3-5 líneas qué vas a hacer y pídeme go/no-go.
2. Si una decisión técnica afecta el roadmap (cambiar librería, refactor grande), pregúntame antes.
3. Si encuentras que algo de este documento es ambiguo o contradictorio, dilo. No asumas.
4. Si una fórmula del estado del arte tiene varias versiones publicadas, escoge la más citada o la más reciente (preferentemente Holtrop 1984 sobre Holtrop 1982; ORC VPP 2023 sobre versiones anteriores) y deja referencia explícita en el docstring.
5. No instales dependencias pesadas (pythonocc, rhino3dm) hasta el sprint que las necesite.
6. Commits frecuentes, mensajes descriptivos, en español.
7. Tests obligatorios para cualquier fórmula numérica antes de declarar el sprint terminado.
8. Documenta a medida que avanzas: docs/theory_manual.md se llena en paralelo al código, no al final.
9. Si un cálculo es lento (>2 s) en un caso típico, muévelo a un QThreadPool para no congelar la UI.
10. Validación visual: cualquier resultado numérico que se muestre en la UI debe poder graficarse al lado, o tener una vista que ayude a interpretarlo (el usuario debe saber leer una curva, no solo un número).

---

20. Empezamos

Cuando hayas leído este documento por completo:

1. Confírmame en 5 líneas máximo qué entendiste, qué dudas tienes (si las hay), y qué vas a entregar al final del Sprint 0.
2. Cuando te diga "go", ejecuta Sprint 0 completo y muéstrame al final cómo abrir la app y qué deberíamos ver.

¿Listo? Empecemos.