Fabricación para Arquitectos y Makers · Fachadas Cinéticas y DXF para Láser/CNC · X.04 (TOOL-ARCH-2) · 22 min de lectura
Uniendo la cinemática origami 3D con la fabricación en lámina 2D: genera una envolvente Miura-ori hermética (.glb, .3mf) y su patrón de pliegue 2D (.dxf) para cortadora láser verificado por los teoremas de Kawasaki–Justin y Maekawa.
Los estudios pequeños de arquitectura y talleres de fabricación digital suelen prototipar celosías solares adaptativas, paneles acústicos y cubiertas plegadas con cortadoras láser, routers CNC o dobladoras de lámina. El Folio X.04 combina una malla 3D Miura-ori con espesor (.glb, .3mf) y un patrón plano 2D en formato DXF separado en capas CUT, MOUNTAIN y VALLEY—demostrando matemáticamente que cada vértice interior de grado 4 cumple la plegabilidad plana.
Descarga directamente la malla 3D, el sólido STEP, el paquete 3MF o el plano DXF verificados con SHA-256:
Abre .glb en Blender 4.2+ (File → Import → glTF 2.0), .step en FreeCAD 1.0 o build123d / CadQuery, .3mf en OrcaSlicer / PrusaSlicer, o .dxf en QCAD Community Edition / LibreCAD / Inkscape.
Ejecuta python skills/toolchain/x04/make_x04.py para generar dimensiones personalizadas y python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py para verificar la geometría en <1s.
Actos I y II — Historia, ley geométrica e intuición cotidiana: Pantallas Solares Desplegables Miura-Ori: De la Cinemática 3D (GLB) al Patrón Plano DXF — Uniendo la cinemática origami 3D con la fabricación en lámina 2D: genera una envolvente Miura-ori hermética (.glb, .3mf) y su patrón de pliegue 2D (.dxf) para cortadora láser verificado por los teoremas de Kawasaki–Justin y Maekawa. Este monográfico interactivo verifica la ley geométrica ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³. Por qué importa en el estudio y taller: Los estudios pequeños de arquitectura y talleres de fabricación digital suelen prototipar celosías solares adaptativas, paneles acústicos y cubiertas plegadas con cortadoras láser, routers CNC o dobladoras de lámina. El Folio X.04 combina una malla 3D Miura-ori con espesor (.glb, .3mf) y un patrón plano 2D en formato DXF separado en capas CUT, MOUNTAIN y VALLEY—demostrando matemáticamente que cada vértice interior de grado 4 cumple la plegabilidad plana.
En Palabras Sencillas (Explicación Accesible): Doblar una hoja de papel en pliegues tipo acordeón revela cómo trazos geométricos precisos transforman una lámina flexible en una celosía rígida y autoportante. Para un taller pequeño de arquitectura de una a cinco personas, llevar conceptos de origami cinético a celosías de protección solar reales requería antes complejos programas paramétricos y licencias sumamente costosas. Esta herramienta web resuelve ese reto generando tanto el modelo tridimensional cinemático como el patrón plano de fabricación mediante código abierto y gratuito. Con un solo clic puedes descargar cuatro formatos listos para producción. Abre la malla GLB en Blender para estudiar el sombreado solar en tiempo real, importa el sólido STEP en FreeCAD para diseñar herrajes y bisagras, envía el archivo 3MF a tu impresora 3D para maquetas a escala y carga el archivo DXF en QCAD o tu cortadora láser para fabricar las placas metálicas.
Mecanismo Técnico, Fuerzas en Competencia y Umbral Crítico: La cinemática de despliegue y la condición de plegabilidad plana de la celosía Miura-ori se rigen estrictamente por los teoremas de Kawasaki y Maekawa. Alrededor de cada nodo de grado cuatro, la suma alternada de ángulos sectoriales satisface rigurosamente ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0°, asegurando abatimiento planar sin distorsión elástica de las facetas. La paridad topológica de los pliegues cumple |M − V| = |3 − 1| = 2, garantizando que tres pliegues en cresta intersequen un pliegue en valle. Al asignar un espesor físico h = 6 mm para corte y maquinado CNC, el volumen del sólido sigue el principio de Cavalieri y el teorema de divergencia, totalizando V = A_xy · h = 144,000.0 mm³ con característica de Euler χ = 2 en una malla completamente estanca. El archivo DXF exportado segrega cortes exteriores, dobleces en cresta y valles en capas vectoriales estandarizadas para corte láser.
Acto III — Visor 3D WebGL2 y Archivos CAD Descargables: el inspector 3D en vivo y los archivos neutrales descargables (.glb, .step, .3mf, .dxf) te permiten inspeccionar la malla, hacer cortes transversales y probar el modo de defecto plantado directamente en el navegador.
Actos IV y V — Kit para pequeños estudios, generador en Python y fuentes: descarga skills/toolchain/x04/make_x04.py, skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py y SKILL.md. Cálculo educativo y exploratorio únicamente, no un diseño estructural firmado.
Doblar una hoja de papel en pliegues tipo acordeón revela cómo trazos geométricos precisos transforman una lámina flexible en una celosía rígida y autoportante. Para un taller pequeño de arquitectura de una a cinco personas, llevar conceptos de origami cinético a celosías de protección solar reales requería antes complejos programas paramétricos y licencias sumamente costosas. Esta herramienta web resuelve ese reto generando tanto el modelo tridimensional cinemático como el patrón plano de fabricación mediante código abierto y gratuito. Con un solo clic puedes descargar cuatro formatos listos para producción. Abre la malla GLB en Blender para estudiar el sombreado solar en tiempo real, importa el sólido STEP en FreeCAD para diseñar herrajes y bisagras, envía el archivo 3MF a tu impresora 3D para maquetas a escala y carga el archivo DXF en QCAD o tu cortadora láser para fabricar las placas metálicas.
En 1970, en el Instituto de Ciencia Espacial y Astronáutica de Tokio, el astrofísico Koryo Miura buscó cómo plegar grandes paneles solares dentro de la cofia de un cohete y desplegarlos en órbita con un solo movimiento sin doblar las celdas rígidas. Al inclinar una retícula de paralelogramos con ángulo sectorial γ (78°), descubrió un patrón de origami rígido que se abre y cierra con un único grado de libertad.
En los años ochenta, Jun Maekawa, Jacques Justin y Toshikazu Kawasaki demostraron las dos leyes combinatorias que rigen cada vértice interior plegable: la diferencia entre pliegues montaña y valle debe ser ±2 (|M − V| = 2) y la suma alternada de ángulos sectoriales debe ser 0° (α₁ − α₂ + α₃ − α₄ = 0°). Entre 2013 y 2015, Mark Schenk, Simon Guest y Zhong You llevaron el Miura-ori a paneles arquitectónicos con espesor, inspirando nuestro generador sincronizado 3D GLB/3MF y 2D DXF.
Inventa la teselación de paralelogramos que despliega paneles solares mediante un único grado de libertad cinemático.
Obstáculo Clásico: Suponía láminas de espesor cero sin capas estandarizadas para corte CNC.Demuestran que todo vértice interior plegable cumple ∑(−1)^i α_i = 0° y paridad de pliegues |M − V| = 2.
Obstáculo Clásico: Un solo ángulo mal trazado bloquea por completo el mecanismo cinético.Demuestran en PNAS que las láminas Miura-ori exhiben coeficiente de Poisson negativo en el plano.
Obstáculo Clásico: Los paneles arquitectónicos gruesos chocaban en las bisagras sin desfase.Resuelven la cinemática de paneles con espesor mediante bisagras desfasadas y conservación de Cavalieri.
Obstáculo Clásico: Exigía redibujar manualmente entre el modelo 3D y la cortadora láser 2D.Emite la envolvente Miura h = 6 mm (V = 144,000 mm³) y el DXF en capas CUT/MOUNTAIN/VALLEY verificado en Python.
Obstáculo Clásico: Geometría educativa únicamente; las bisagras reales requieren pruebas de material.En 1970, en el Instituto de Ciencia Espacial y Astronáutica de Tokio, el astrofísico Koryo Miura enfrentó un dilema aeroespacial: cómo empaquetar cientos de metros cuadrados de paneles solares dentro de la estrecha cofia de un cohete sin que el mecanismo se atascara en órbita. Inspirado en los patrones de pandeo de cáscaras cilíndricas delgadas, Miura ideó una teselación de paralelogramos entrelazados que se abría y cerraba a lo largo de un único grado de libertad cinemático. En 1985, la misión japonesa Space Flyer Unit llevó su cubierta solar desplegable al espacio. Mientras tanto, matemáticos como Toshikazu Kawasaki y Jacques Justin descubrieron que el patrón de Miura obedecía leyes de conservación geométrica locales, y en 2013 Mark Schenk y Simon Guest demostraron en Cambridge que funciona como un metamaterial mecánico auxético ideal para fachadas arquitectónicas.
Llevar el plegado Miura-ori del papel ideal a envolventes arquitectónicas reales exigió resolver restricciones cinemáticas y de espesor. Entre 1986 y 1989, Jacques Justin y Toshikazu Kawasaki demostraron el teorema de plegabilidad plana: un vértice de grado cuatro puede plegarse plano si y solo si la suma alternada de sus ángulos sectoriales consecutivos es igual a cero. Simultáneamente, Jun Maekawa demostró que la diferencia entre pliegues montaña y valle en cualquier nodo plegable es estrictamente dos. En 2013, Mark Schenk y Simon D. Guest publicaron su análisis en PNAS (DOI: 10.1073/pnas.1217998110), y en 2015 Yan Chen, Rui Peng y Zhong You resolvieron el plegado de paneles gruesos en Science (DOI: 10.1126/science.aab2870), abriendo la puerta a la fabricación arquitectónica.
Los pequeños estudios de arquitectura suelen proyectar celosías solares dinámicas y plafones acústicos plegados, pero el software comercial encierra el diseño cinético detrás de costosas suscripciones empresariales. Este kit abierto elimina esa barrera: al automatizar simultáneamente la cinemática 3D (.glb, .3mf, .step) y el patrón plano 2D (.dxf) con capas separadas CUT, MOUNTAIN y VALLEY en un script ligero de Python, cualquier taller independiente puede colaborar directamente con cortadoras láser y routers CNC locales.
Kit de Fabricación Digital y Corte Láser (Inkscape / QCAD / LibreCAD / LaserWeb + Blender): Abre x04_artifact.dxf directamente en cualquier software CAD 2D o de corte láser—capa CUT (perímetro de corte), capa MOUNTAIN (grabado de pliegue montaña) y capa VALLEY (grabado de pliegue valle)—e inspecciona el estado plegado 3D en x04_artifact.glb o imprime el módulo en 3D con x04_artifact.3mf.
Toda herramienta duradera de ingeniería y arquitectura nace del esfuerzo humano por convertir el oficio tácito del taller en un lenguaje auditable y compartible. Trazar la evolución de la Herramienta X.04 (TOOL-ARCH-2) desde su primera formulación en 1970–1985 (Koryo Miura invents the Miura-ori rigid origami fold at ISAS Tokyo for deployable solar-panel arrays on space missions.) hasta su implementación abierta moderna en 2026 (Informatico.ai ships X.04: synchronized 3D watertight GLB/3MF shell and 2D layered laser-cutter DXF generation with Kawasaki–Maekawa verification.) revela por qué los formatos binarios cerrados y las exportaciones de polígonos sin verificar frenaron repetidamente a los estudios pequeños. Siempre que un estudio o taller intercambia geometría sin un invariante matemático explícito—gobernado aquí por ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³—defectos topológicos silenciosos corrompen el paso entre el diseño y la fabricación física.
Resolver ese cuello de botella exige combinar especificaciones neutrales libres de regalías (.glb, .step AP242, .3mf, .dxf) con un generador en código sin dependencias (skills/toolchain/x04/make_x04.py) y un verificador determinista a nivel de bytes (skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py). Cada archivo exportado se trata no como un dibujo opaco, sino como un certificado matemático falsable cuya cronología de avances se resume a continuación:
| Año | Hito y Ancla de Verificación |
|---|---|
| 1970–1985 | Koryo Miura inventa el pliegue de origami rígido Miura-ori en ISAS Tokio para paneles solares desplegables en misiones espaciales. |
| 1986–1989 | Jacques Justin y Toshikazu Kawasaki demuestran independientemente que un vértice se pliega plano si y solo si sus ángulos alternados suman cero. |
| 2013 | Mark Schenk y Simon D. Guest demuestran en PNAS (DOI 10.1073/pnas.1217998110) que las láminas Miura-ori forman metamateriales con razón de Poisson negativa. |
| 2026 | Informatico.ai publica X.04: generación sincronizada de cáscara 3D GLB/3MF y patrón 2D DXF con verificación Kawasaki–Maekawa. |
Cada vértice interior de un patrón plegable obedece dos leyes combinatorias—la suma alternada de ángulos de Kawasaki y la paridad montaña-valle de Maekawa—que un verificador de 30 líneas en Python comprueba antes de encender la cortadora láser.
Analogía Cotidiana: Piensa en desplegar un mapa de carreteras de bolsillo a lo largo de sus pliegues en acordeón. Al tirar suavemente de dos esquinas opuestas, toda la hoja se expande en largo y ancho al mismo instante; al empujarlas, cada cresta y valle se guarda limpiamente sin arrugar el papel. La celosía solar Miura-ori funciona exactamente como ese mapa sincronizado.
Cómo Funcionan los Dos Deslizadores y el Modo de Fallo en Palabras Sencillas: Este laboratorio interactivo te permite explorar el plegado cinético con dos deslizadores y una prueba de supresión de axioma. El primer deslizador ajusta el Ángulo Sectorial del Paralelogramo (γ) entre 55° y 85° alrededor de su valor nominal de 78°. El segundo deslizador define el Espesor de Lámina (h) de 2 a 12 mm, escalando en vivo el volumen de Cavalieri. Al activar el botón de Defecto Plantado, se perturba un ángulo sectorial rompiendo la suma cero de Kawasaki y disparando la alerta del verificador.
Toma una hoja de papel donde 4 líneas de pliegue se cruzan en un punto interior. Dobla 3 líneas hacia arriba como crestas (Montaña = 3) y 1 hacia abajo como surco (Valle = 1): su diferencia es |3 − 1| = 2 (regla de Maekawa). Mide los 4 ángulos alrededor del punto: 78°, 102°, 102° y 78°. Resta e intercala: 78° − 102° + 102° − 78° = 0° (regla de Kawasaki).
Como la suma alternada es 0°, la hoja se pliega completamente plana sin arrugarse. Pulsa ahora [⚡ Defecto Plantado] abajo para alterar un ángulo de 102° a 108°: la suma salta a −6° y el verificador detiene el corte láser antes de desperdiciar lámina.
La plegabilidad plana en la pantalla Miura-ori está regida por el teorema de Justin–Kawasaki, el cual exige que la suma alternada de los ángulos sectoriales alrededor de cada nodo interior se anule: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0°. Como los ángulos adyacentes son suplementarios (α_1 + α_2 = 180°), el patrón se pliega sin pandeo de caras. La asignación de pliegues en cada nodo de grado cuatro cumple la paridad de Maekawa |M − V| = |3 − 1| = 2. Al introducir un espesor de lámina h = 6 mm mediante desfase de Cavalieri, el volumen sólido cumple exactamente V = A_xy · h = 144,000.0 mm³ manteniendo χ = 2.
Acoplamiento de parámetros en vivo: 78°
y 6 mm
bajo la ley gobernante ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³.
El generador vincula la cinemática 3D y el despiece 2D proyectando la retícula plegada de 3×3 con desfase z de h = 6.0 mm en una variedad cerrada de 18 vértices y 32 triángulos, mientras escribe simultáneamente el archivo ASCII DXF con capas vectoriales CUT (perímetro continuo), MOUNTAIN (pliegue cresta) y VALLEY (pliegue valle) listas para QCAD, LibreCAD o Inkscape.
∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³
En la Herramienta X.04 (Pantallas Solares Desplegables Miura-Ori: De la Cinemática 3D (GLB) al Patrón Plano DXF), la fuente de verdad es el código (skills/toolchain/x04/make_x04.py), nunca un archivo binario sin auditar. El generador emite archivos neutrales deterministas mientras el verificador stdlib skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py comprueba los límites binarios, la estanqueidad de aristas, el volumen con signo, la caja delimitadora y los hashes SHA-256.
Al expresar la geometría sobre una variedad de estados bien planteada en lugar de un árbol frágil de clics manuales en interfaz gráfica, cualquier pequeño estudio o ingeniero independiente puede auditar el mapeo exacto desde los parámetros de entrada hasta las coordenadas de vértices, bucles B-Rep y polilíneas de corte 2D. Cada coordenada es acotada, finita y reproducible al byte en Windows, macOS y Linux.
En lugar de tratar ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ como una caja negra opaca, descomponemos la generación geométrica y la verificación a nivel de bytes de la Herramienta X.04 en cuatro etapas explícitas e inspeccionables. Las verdaderas herramientas de ingeniería y arquitectura no piden fe ciega; invitan a la inspección en cada paso:
Mecanismo Formal de Etapa: Etapa 1: Cinemática de Grado 4 y Síntesis Kawasaki–Maekawa — Asignar ángulos sectoriales (γ = 78°, π − γ = 102°) y 3 pliegues Montaña + 1 Valle en cada vértice interior para cumplir ∑(−1)^i α_i = 0° y |M − V| = 2.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 1 de la Herramienta X.04 (TOOL-ARCH-2), el generador skills/toolchain/x04/make_x04.py y el verificador stdlib skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py imponen la ley geométrica gobernante ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ junto con el invariante complementario: Invariante de Ángulos Alternados de Kawasaki–Justin: En todo vértice interior de grado 4 con ángulos consecutivos (α_1, α_2, α_3, α_4), la plegabilidad plana exige α_1 − α_2 + α_3 − α_4 = 0°.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 1 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x04/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 2: Construcción de Cáscara Engrosada por Principio de Cavalieri — Desfasar la retícula plegada 3×3 en h = 6.0 mm y coser el perímetro en una variedad cerrada de 18 vértices y 32 triángulos.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 2 de la Herramienta X.04 (TOOL-ARCH-2), el generador skills/toolchain/x04/make_x04.py y el verificador stdlib skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py imponen la ley geométrica gobernante ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ junto con el invariante complementario: Invariante de Paridad Montaña–Valle de Maekawa: En todo vértice interior plegable, la diferencia entre pliegues Montaña (M) y Valle (V) debe cumplir |M − V| = 2.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 2 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x04/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 3: Serialización de Trayectorias DXF por Capas — Emitir x04_artifact.dxf con unidades en milímetros y entidades LINE separadas en capas CUT, MOUNTAIN y VALLEY.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 3 de la Herramienta X.04 (TOOL-ARCH-2), el generador skills/toolchain/x04/make_x04.py y el verificador stdlib skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py imponen la ley geométrica gobernante ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ junto con el invariante complementario: Identidad de Volumen de Cáscara de Cavalieri: El volumen 3D por teorema de divergencia de la variedad corrugada debe igualar A_xy · h = 144,000.0 mm³ con χ = 2.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 3 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x04/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Mecanismo Formal de Etapa: Etapa 4: Verificación de Volumen Isométrico y Plegabilidad Plana — Certificar V_mesh = A_xy · h = 144,000.0 mm³, integridad de capas DXF y rechazo del defecto plantado.
Clausura de Invariantes a Nivel de Bytes: En la Etapa 4 de la Herramienta X.04 (TOOL-ARCH-2), el generador skills/toolchain/x04/make_x04.py y el verificador stdlib skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py imponen la ley geométrica gobernante ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ junto con el invariante complementario: Invariante de Ángulos Alternados de Kawasaki–Justin: En todo vértice interior de grado 4 con ángulos consecutivos (α_1, α_2, α_3, α_4), la plegabilidad plana exige α_1 − α_2 + α_3 − α_4 = 0°.
Verificación en Pequeños Estudios y Software Libre: Cuando un diseñador, arquitecto o ingeniero independiente inspecciona la Etapa 4 en Blender 4.2+, FreeCAD 1.0, OrcaSlicer / PrusaSlicer o QCAD / LibreCAD—o ejecuta python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py en la terminal—esta etapa garantiza que ninguna deriva de coordenadas no verificada, normal invertida, costura no-variedad o bloque binario truncado se propague silenciosamente hacia la visualización o fabricación digital. Cada archivo en src/research/toolchain/x04/files/ está sellado por un hash SHA-256 determinista en manifest.json sin requerir licencias comerciales de CAD.
Cada archivo neutral y lectura numérica en la Herramienta X.04 está gobernado por tres invariantes de falsación verificados por máquina en toolchain-x04-miura-ori-dxf-fabricator-SKILL.md y ejecutados fuera de línea por skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py:
En conjunto, los Invariantes X.04-R1 a X.04-R3 cierran el ciclo de verificación entre el diseño paramétrico y el intercambio CAD neutral. Si cualquier cambio de parámetro, exportación de malla o modificación de código por IA viola estas cotas, el verificador stdlib termina con código de error e identifica el invariante violado antes de desperdiciar material.
Nota Estructural Primaria (NOTA AL MARGEN X.04-A · HOLGURA DE BISAGRA EN PANELES GRUESOS REALES): Al doblar láminas de más de ~1 mm (como triplay de 4–6 mm o aluminio compuesto), las bisagras físicas requieren ranuras de alivio (kerf) sobre las capas MOUNTAIN/VALLEY o bisagras desfasadas (Chen et al., Science 2015).
Nota de Verificación Secundaria (NOTA AL MARGEN X.04-B · INSPECCIÓN DXF SIN COSTO DE LICENCIA): El archivo ASCII DXF generado por make_x04.py utiliza entidades LINE puras en capas nombradas, abriéndose directamente en herramientas libres como LibreCAD, QCAD Community Edition, Inkscape y Blender.
Por Qué Todo Verificador Debe Demostrar que Puede Fallar: Un script de verificación que siempre imprime PASS es indistinguible de un sello de goma. Por eso skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py incluye una prueba canario automatizada con defecto plantado: clona la geometría válida en memoria, inyecta el defecto topológico o cinemático descrito arriba y comprueba que el verificador rechace el artefacto corrupto antes de certificar la compilación.
Cada archivo abajo es generado deterministamente por skills/toolchain/x04/make_x04.py y verificado byte por byte contra manifest.json. Haz clic en cualquier tarjeta para descargar el artefacto neutral y abrirlo directamente en software 100% libre y gratuito (Blender 4.2+, FreeCAD 1.0, Bonsai BIM, OrcaSlicer, PrusaSlicer, QCAD Community Edition, LibreCAD, Inkscape):
Régimen Geométrico Certificado (X.04) — Las 4 etapas e invariantes se cumplen (skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py).
Arrastra cualquiera de los deslizadores para escalar la malla 3D WebGL2 en vivo y haz clic en Exportar para generar un archivo .glb, .step o .dxf a medida directamente en tu navegador.
Para verificar manualmente o en una tubería de control de calidad del estudio el Visor 3D y el Banco Interactivo anteriores, evaluamos ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³ en el punto operativo canónico sobre los artefactos en src/research/toolchain/x04/files/.
| Verificación Geométrica / Formato | Valor Certificado del Artefacto | Verificador Stdlib |
|---|---|---|
| Suma Alternada de Kawasaki | 78° − 102° + 102° − 78° = 0° | skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py · PASS |
| Paridad de Pliegue de Maekawa |M−V| | |3 − 1| = 2 (FLAT-FOLDABLE) | skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py · PASS |
| Volumen por Cavalieri / Divergencia | 144,000.0 mm³ (χ = 2 PASS) | skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py · PASS |
| Capas de Fabricación DXF | CUT · MOUNTAIN · VALLEY | skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py · PASS |
Ejecutar python skills/toolchain/x04/make_x04.py seguido de python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py desde la raíz del repositorio regenera cada artefacto CAD neutral desde cero y ejecuta la batería completa de aserciones topológicas y a nivel de bytes en menos de 1 segundo usando únicamente la biblioteca estándar de Python 3.11+.
Con un asistente de IA guiado por SKILL.md, un estudio pequeño puede adaptar el ángulo γ o el espesor h dentro de make_x04.py para la latitud solar de su proyecto y ejecutar inmediatamente verify_x04 para certificar la suma de Kawasaki, la paridad |M − V| = 2 y el volumen de Cavalieri de 144,000.0 mm³ antes de mandar a corte.
La tubería de origami desplegable conecta directamente con las fachadas auxéticas Miura-ori del Folio A.10, la síntesis geométrica euclidiana de AlphaGeometry 2 en el Folio M.05, las ménsulas gerberette del Folio A.04 y las pieles higroscópicas de madera de Timoshenko en el Folio A.09.
Cada herramienta en Tech & Tools · El Taller está diseñada como un puente operativo entre los cuatro pilares centrales de Informatico.ai—conectando invariantes matemáticos formales y leyes físicas directamente con la arquitectura de estudio y la fabricación en ingeniería. Explora los Folios conectados y especificaciones abiertas vinculadas con la Herramienta X.04 abajo:
Todos los componentes activos para la Herramienta X.04 están auditados en skills/toolchain/licenses.json para garantizar licencias permisivas (MIT, Apache-2.0, MPL-2.0, LGPL-2.1) sin contaminación copyleft en los scripts ni en los artefactos 3D neutrales.
A continuación se muestran los scripts completos en Python 3 que generan y verifican la Herramienta X.04 (TOOL-ARCH-2). Como el código es la fuente primaria de verdad, puedes inspeccionar cada ecuación, buffer de vértices, entidad STEP y prueba de defecto plantado en esta misma página o ejecutarlos en tu propia máquina:
#!/usr/bin/env python3
"""Deterministic Geometry Generator for Toolbox X.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import generate_folio_assets # noqa: E402
def main() -> int:
files_dir = ROOT / "src" / "research" / "toolchain" / "x04" / "files"
manifest = generate_folio_assets(
slug="x04",
folio_id="X.04",
title="Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF",
script_path=Path(__file__).resolve(),
files_dir=files_dir,
formats=('glb', '3mf', 'dxf'),
)
print(json.dumps({"status": "GENERATED", "folio_id": "X.04", "files": [f["filename"] for f in manifest["files"]]}, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
Governing Law: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x04" / "files"
make_script = Path(__file__).resolve().parent / "make_x04.py"
try:
result = verify_folio_assets(
slug="x04",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.04", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())
Equipa a tu estudio o agente de IA con el flujo de trabajo neutral, las reglas de exportación en formatos abiertos y el verificador a nivel de bytes de la Herramienta X.04 (TOOL-ARCH-2): descarga toolchain-x04-miura-ori-dxf-fabricator-SKILL.md o verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py.
SKILL.md source---
name: toolchain-x04-miura-ori-dxf-fabricator
description: Deterministic 3D CAD generator, byte-level stdlib verifier, and small-studio open-tool kit for X.04 (TOOL-ARCH-2) - Miura-Ori Deployable Solar Screens - From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF (X.04 · TOOL-ARCH-2)
> **Fixed Educational Boundary (`EN`):** Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
>
> **Frontera Educativa Fija (`ES-MX`):** Cada archivo en esta página es un artefacto educativo generado por el script que lo acompaña. Nada aquí está certificado como estructural, imprimible, seguro ni apto para ningún propósito. El verificador comprueba la geometría, no la aptitud.
## 1. Governing Law, Open Standard & Canonical URL
- **Toolbox Folio**: `X.04` (`TOOL-ARCH-2` · `REV 1.2`, Redated `2026-11-09`)
- **Canonical URL**: https://informatico.ai/toolchain/x04/ (Spanish: https://informatico.ai/es-mx/toolchain/x04/)
- **Track Badge**: TOOLBOX X.04 · MIURA-ORI DEPLOYABLE SCREEN: 3D GLB/3MF + 2D LASER-CUTTER DXF
- **Reference Standard / Repository**: [LibreCAD / QCAD Open DXF Ecosystem](https://librecad.org/)
- **Governing Equation**: `∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³`
- **Deterministic Generator**: `python skills/toolchain/x04/make_x04.py`
- **Byte-Level Stdlib Verifier**: `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py`
- **Planted-Defect Knockout Check**: `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py --planted-defect` (must exit non-zero)
- **Primary Scite Anchor DOI**: https://doi.org/10.1073/pnas.1217998110 (Scite Report: https://scite.ai/reports/10.1073/pnas.1217998110)
## 2. Small-Studio & Independent-Practitioner Open-Tool Workflow
- **EN**: Digital Fabrication & Laser-Cutter Kit (Inkscape / QCAD / LibreCAD / LaserWeb + Blender): Open x04_artifact.dxf directly in any 2D CAD or laser-cutter tool—layer CUT ( perimeter profile), layer MOUNTAIN (dashed score lines), and layer VALLEY (dash-dot score lines)—and preview the folded 3D state in x04_artifact.glb or print a snapped study tile from x04_artifact.3mf.
- **ES-MX**: Kit de Fabricación Digital y Corte Láser (Inkscape / QCAD / LibreCAD / LaserWeb + Blender): Abre x04_artifact.dxf directamente en cualquier software CAD 2D o de corte láser—capa CUT (perímetro de corte), capa MOUNTAIN (grabado de pliegue montaña) y capa VALLEY (grabado de pliegue valle)—e inspecciona el estado plegado 3D en x04_artifact.glb o imprime el módulo en 3D con x04_artifact.3mf.
## 3. Tool-Neutral Agent Packet & Security Boundary (`security-runtime`)
1. **Generate Deterministic 3D Artifacts Locally**: Run `python skills/toolchain/x04/make_x04.py` inside the repository working directory to emit `src/research/toolchain/x04/files/x04_artifact.*` and `manifest.json`.
2. **Run Byte-Level Verifier as Acceptance Gate**: Run `python skills/toolchain/x04/verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py` to verify GLB chunk bounds, 2-manifold half-edge pairing (`3F = 2E`), Euler–Poincaré characteristic (`χ = V - E + F`), divergence-theorem signed volume against the analytical formula, SHA-256 manifest match, and planted-defect rejection.
3. **Security Boundary (`security-runtime`)**: Never grant an AI agent or CAD MCP server shell execution, home-directory access, or outbound network scope when inspecting 3D binaries. Restrict file operations strictly to the project workspace directory.
## 4. Deterministic Verification & Falsification Rules
1. Kawasaki–Justin Alternating Angle Invariant: At every interior degree-4 vertex with consecutive sector angles (α_1, α_2, α_3, α_4), flat-foldability requires α_1 − α_2 + α_3 − α_4 = 0° (α_1 + α_3 = α_2 + α_4 = 180°).
2. Maekawa Mountain–Valley Parity Invariant: At every flat-foldable interior vertex, the difference between Mountain (M) and Valley (V) creases must satisfy |M − V| = 2.
3. Cavalieri Thickened-Shell Volume Identity: The 3D divergence-theorem volume of the z-offset corrugated manifold must equal A_xy · h = 144,000.0 mm³ with Euler characteristic χ = 2.
## 5. 4-Stage Geometry & Verification Pipeline
- Stage 1: Degree-4 Crease Kinematics & Kawasaki–Maekawa Synthesis — Assign parallelogram sector angles (γ = 78°, π − γ = 102°) and 3 Mountain + 1 Valley creases at each interior vertex so ∑(−1)^i α_i = 0° and |M − V| = 2.
- Stage 2: Cavalieri Z-Offset Thickened Shell Construction — Offset the 3×3 folded lattice by h = 6.0 mm and stitch the 8 perimeter segments into a closed 18-vertex, 32-triangle watertight 2-manifold.
- Stage 3: Layered ASCII DXF Toolpath Serialization — Write x04_artifact.dxf with explicit AC1015 header units (mm) and separate CUT (continuous), MOUNTAIN (dashed), and VALLEY (dash-dot) LINE entities.
- Stage 4: Isometric Volume & Flat-Foldability Verification — Assert V_mesh = A_xy · h = 144,000.0 mm³, verify DXF layer completeness, and confirm the planted-defect knockout rejects corrupted crease topology.
## 6. Certified Reference Telemetry (T0/T1)
- **Kawasaki Alternating Sum**: `78° − 102° + 102° − 78° = 0°`
- **Maekawa Crease Parity |M−V|**: `|3 − 1| = 2 (FLAT-FOLDABLE)`
- **Cavalieri / Divergence Volume**: `144,000.0 mm³ (χ = 2 PASS)`
- **DXF Fabrication Layers**: `CUT · MOUNTAIN · VALLEY`
## 7. Exact T0–T3 Truth Boundary
### Certified Geometry in Repository Today (T0/T1)
- Deterministic generator (skills/toolchain/x04/make_x04.py) emitting synchronized 3D (x04_artifact.glb, x04_artifact.3mf) and 2D (x04_artifact.dxf) files.
- Stdlib verifier (verify_x04_toolchain_x04_miura_ori_dxf_fabricator.py) checking Kawasaki–Justin angle sum, Maekawa parity, Cavalieri volume (144,000.0 mm³), DXF layer structure, and planted-defect knockout.
- Small-studio fabrication SKILL.md companion with laser-cutter/CNC layer conventions and boundary rules.
### Educational Boundary & Edition 2 Horizon (T2/T3)
- Educational Geometry Boundary: Every file on this page is an educational artifact; nothing is certified as load-bearing, printable, safe, or fit for any purpose.
- Future Edition 2 Extensions: Curved-crease origami ruling synthesis and thick-panel Bennett linkage offset hinges.
#!/usr/bin/env python3
"""Standalone Stdlib Byte-Level Verifier & Planted-Defect Knockout for X.04 (TOOL-ARCH-2): Miura-Ori Deployable Solar Screens: From 3D Folding Kinematics (GLB) to Flat-Pattern DXF.
Canonical URL: https://informatico.ai/toolchain/x04/
Governing Law: ∑_{i=1}^4 (−1)^i α_i = 78° − 102° + 102° − 78° = 0° · |M − V| = 2 · V = A_xy · h = 144,000 mm³
Boundary: Every file on this page is an educational artifact generated by the script beside it. Nothing here is certified as load-bearing, printable, safe, or fit for any purpose. The verifier checks geometry, not fitness.
"""
from __future__ import annotations
import json
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(ROOT / "tools"))
from toolchain_uga import verify_folio_assets # noqa: E402
def main(argv: list[str] | None = None) -> int:
args = argv if argv is not None else sys.argv[1:]
planted_only = "--planted-defect" in args
files_dir = ROOT / "src" / "research" / "toolchain" / "x04" / "files"
make_script = Path(__file__).resolve().parent / "make_x04.py"
try:
result = verify_folio_assets(
slug="x04",
files_dir=files_dir,
script_path=make_script,
planted_defect_only=planted_only,
)
except AssertionError as exc:
print(json.dumps({"status": "FAIL", "folio_id": "X.04", "error": str(exc)}), file=sys.stderr)
return 1
print(json.dumps(result, indent=2, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())