openscad-cpp-evaluator 1.31.0__tar.gz → 1.33.0__tar.gz

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/.github/workflows/wheels.yml

@@ -119,6 +119,9 @@ jobs:
           # C:\msys64 (not on PATH); its bison/flex satisfy the parser
           # submodule's grammar version requirement.
           CIBW_BEFORE_ALL_WINDOWS: 'C:\msys64\usr\bin\bash.exe -lc "pacman -Sy --noconfirm bison flex"'
+          # The binding tests run under pytest (the file's own entry point
+          # hands over to it): most of them take tmp_path or use pytest.raises.
+          CIBW_TEST_REQUIRES: "pytest"
           CIBW_TEST_COMMAND: "python {package}/tests/test_python_bindings.py"
 
       - uses: actions/upload-artifact@v7
@@ -128,6 +131,9 @@ jobs:
 
   publish-testpypi:
     needs: [sdist, build_wheels]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     environment: testpypi
     steps:
@@ -164,6 +170,9 @@ jobs:
 
   publish-pypi:
     needs: [publish-testpypi]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     # The "pypi" environment carries no protection rules, so a tag runs
     # straight through TestPyPI to PyPI with nothing to stop it -- and a

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/CLAUDE.md

@@ -1091,8 +1091,8 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all ten
-  formats `exportExtensions()` lists: 3MF, AMF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all twelve
+  formats `exportExtensions()` lists: 3MF, AMF, DXF, PDF, STL, OBJ, OFF, PLY, POV, SVG, VRML, X3D (3MF via
   `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
   which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
   restating the list, because three hand-written copies had already drifted far enough that `.off`
@@ -1120,6 +1120,30 @@ grep for `ponytail:`.
   binary's, vertex order and 6-vertex line wrap included. A 3D body in the list throws
   ("Current top level object is not a 2D object"), as OpenSCAD refuses too: there is no projection
   to fall back on. `ExportOptions::svg` carries OpenSCAD's five `-O export-svg/...` settings.
+  **`writePov` writes POV-Ray, as `mesh2`** — one per object `splitBodiesForExport` produces, with
+  a welded vertex list, a `texture_list` of the object's colours and a texture index per triangle
+  (so per-triangle colour needs no unwelding, unlike PLY), and `inside_vector` so POV-Ray treats it
+  as a SOLID (the `ior 1.32` interior refracts; CSG works). OpenSCAD's `export_pov.cc` writes every
+  face as its own flat `polygon` object instead. The rest of the scene is OpenSCAD's: header,
+  MATERIAL finish, 27 lights around the bounding box, radiosity from `rad_def.inc`, colour as
+  `rgbf` with filter = 1 − alpha. `ExportPovOptions::camera` ($vpt, $vpr, distance, fov; Python
+  `pov_camera`, 8 numbers) writes OpenSCAD's camera block with **two fixes, both found by rendering
+  in POV-Ray 3.7 and comparing with BelfrySCAD's PNG of the same camera** (they now agree to a
+  pixel): `rotate` comes before `translate`, since the eye orbits `$vpt` (OpenSCAD translates first
+  and frames the wrong place when a view both pans and turns); and the viewport's **vertical** fov
+  becomes POV-Ray's **horizontal** `angle` through an expression on `image_width/image_height`
+  (OpenSCAD writes it across unchanged, zooming its renders in by the aspect ratio). No camera frames
+  the bounding box, as OpenSCAD does without one.
+  **`writeDxf` is the third 2D writer**, also on `collect2d()`: OpenSCAD's own `export_dxf.cc`
+  layout verbatim (AC1006 header with the extents, one CONTINUOUS linetype, layer 0, every contour
+  a closed `LWPOLYLINE` on layer 0 with holes as ordinary contours; 1- and 2-vertex contours as
+  `POINT`/`LINE`), pinned byte-for-byte by `ExportDxf.MatchesRealOpenscadByteForByte`. Two
+  deliberate differences: coordinates are the **shortest text that round-trips the double**
+  (`dxfNum`), not OpenSCAD's 6 significant digits -- a DXF feeds a cutter, and its circles do not
+  survive a re-import otherwise; and `$EXTMAX` is right for a model below zero (OpenSCAD seeds its
+  maxima with `numeric_limits<double>::min()`, the smallest POSITIVE double). Every number goes
+  through the classic locale, the file stream included: Qt sets the process locale, and a grouping
+  locale writes a 1500-vertex count as `1.500`.
   **`writePdf` is the other 2D writer**, and shares `collect2d()` with `writeSvg` so the all-2D
   rule and its refusal have one implementation. Everything else differs from SVG: the drawing is
   **centred on a fixed paper size** rather than the page being cut to fit, and **PDF user space is

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.31.0
+Version: 1.33.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/bindings/module.cpp

@@ -436,14 +436,30 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
                         bool stripSlivers, bool splitComponents, bool splitColors, bool svgFill,
                         const std::string& svgFillColor,
                         bool svgStroke, const std::string& svgStrokeColor, double svgStrokeWidth,
-                        nb::object pdfOptions) {
+                        nb::object pdfOptions, nb::object povCamera) {
     oscadeval::ExportPdfOptions pdf;
     if (!pdfOptions.is_none()) applyPdfOptions(nb::cast<nb::dict>(pdfOptions), pdf);
+    oscadeval::ExportPovOptions pov;
+    if (!povCamera.is_none()) {
+        const std::vector<double> c = nb::cast<std::vector<double>>(povCamera);
+        if (c.size() != 8) {
+            throw std::runtime_error("pov_camera takes 8 numbers: $vpt x, y, z, $vpr x, y, z, distance, fov");
+        }
+        oscadeval::ExportPovCamera cam;
+        for (int k = 0; k < 3; ++k) {
+            cam.vpt[k] = c[k];
+            cam.vpr[k] = c[3 + k];
+        }
+        cam.distance = c[6];
+        cam.fov = c[7];
+        pov.camera = cam;
+    }
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
         oscadeval::ExportOptions opts;
         opts.pdf = pdf;
+        opts.pov = pov;
         opts.format = format;
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
@@ -957,7 +973,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           nb::arg("svg_fill") = false,
           nb::arg("svg_fill_color") = std::string("white"), nb::arg("svg_stroke") = true,
           nb::arg("svg_stroke_color") = std::string("black"), nb::arg("svg_stroke_width") = 0.35,
-          nb::arg("pdf_options") = nb::none(),
+          nb::arg("pdf_options") = nb::none(), nb::arg("pov_camera") = nb::none(),
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
@@ -976,7 +992,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "(paper-size, orientation, show-scale, show-scale-message, show-grid, grid-size, "
           "show-filename, design-filename, fill, fill-color, stroke, stroke-color, stroke-width, "
           "add-meta-data, title, author, subject, keywords). An unknown key raises rather than "
-          "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.");
+          "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.\n\n"
+          "pov_camera is .pov's camera as 8 numbers -- $vpt x, y, z, $vpr x, y, z, distance, fov -- "
+          "so a POV-Ray render frames what the viewport showed. None frames the model from its "
+          "bounding box, as OpenSCAD does without a camera.");
 
     m.def("list_fonts", []() {
         nb::list out;

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/include/openscad_cpp_evaluator/export.hpp

@@ -4,6 +4,7 @@
 
 #include <array>
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -158,6 +159,17 @@ struct ExportSvgOptions {
 void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
               const ExportSvgOptions& opts = {});
 
+// DXF, the third 2D writer: OpenSCAD's own export_dxf.cc layout (an AC1006
+// header with the model's extents, one CONTINUOUS linetype, layer 0) and
+// every contour of every body a closed LWPOLYLINE on layer 0 -- holes are
+// contours like any other, as in OpenSCAD. A 1-vertex contour is a POINT
+// and a 2-vertex one a LINE, again as OpenSCAD writes them. Shares
+// collect2d() with writeSvg/writePdf, so a 3D model is refused the same
+// way. Coordinates are written at full round-trip precision, NOT OpenSCAD's
+// 6 significant digits: a DXF goes to a cutter, where 1234.567 written as
+// 1234.57 is a real error.
+void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies);
+
 // Options for the PDF writer, named and defaulted after OpenSCAD's own
 // `-O export-pdf/...` set.
 struct ExportPdfOptions {
@@ -222,6 +234,33 @@ std::vector<std::string> writePdf(const std::string& path, const std::vector<Col
 
 // -- one entry point ------------------------------------------------------
 
+// POV-Ray's camera, as OpenSCAD's viewport states it: $vpt, $vpr, $vpd and
+// the field of view. Without one the scene is framed from the model's
+// bounding box, as OpenSCAD frames it when it has no camera to pass.
+struct ExportPovCamera {
+    double vpt[3] = {0, 0, 0};
+    double vpr[3] = {0, 0, 0};
+    double distance = 0;
+    double fov = 22.5;
+};
+
+struct ExportPovOptions {
+    std::optional<ExportPovCamera> camera;
+};
+
+// POV-Ray scene description. Every object splitBodiesForExport produces is
+// one mesh2 -- a welded vertex list, a texture per colour, and a texture
+// index per triangle, so per-triangle colour needs no unwelding -- with
+// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). That
+// is the difference from OpenSCAD's export_pov.cc, which writes every face
+// as its own flat polygon object. The rest of the scene is OpenSCAD's: its
+// header, MATERIAL finish and ior 1.32 interior, 27 lights around the
+// bounding box, its camera, and radiosity from rad_def.inc. Colour is rgbf
+// with filter = 1 - alpha, as OpenSCAD writes it. Numbers are the shortest
+// text that round-trips, in the classic locale.
+void writePov(const std::string& path, const std::vector<ExportObject>& objects,
+              const ExportPovOptions& opts = {});
+
 struct ExportOptions {
     // Empty means "decide from the path's extension".
     std::string format;
@@ -247,6 +286,8 @@ struct ExportOptions {
     ExportSvgOptions svg;
     // .pdf only.
     ExportPdfOptions pdf;
+    // .pov only.
+    ExportPovOptions pov;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.31.0"
+version = "1.33.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/python/openscad_cpp_evaluator/__init__.py

@@ -331,7 +331,8 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
                  split_colors: bool = True,
                  svg_fill: bool = False, svg_fill_color: str = "white",
                  svg_stroke: bool = True, svg_stroke_color: str = "black",
-                 svg_stroke_width: float = 0.35, pdf_options: dict | None = None) -> list:
+                 svg_stroke_width: float = 0.35, pdf_options: dict | None = None,
+                 pov_camera=None) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
@@ -374,12 +375,17 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     size with nothing to explain it. `.pdf` is 2D-only like `.svg`, and
     centres the drawing on a fixed paper size instead of cutting the page
     to fit.
+
+    `pov_camera` is `.pov`'s camera as eight numbers -- `$vpt` x, y, z,
+    `$vpr` x, y, z, distance, field of view -- so a POV-Ray render frames
+    what the viewport showed. None frames the model from its bounding box,
+    as OpenSCAD does when it has no camera to pass.
     """
     try:
         return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
                                        split_components, split_colors, svg_fill, svg_fill_color,
                                        svg_stroke, svg_stroke_color, svg_stroke_width,
-                                       pdf_options))
+                                       pdf_options, pov_camera))
     except Exception as e:
         raise EvalError(str(e)) from e
 

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.33.0}/src/export.cpp

@@ -13,6 +13,8 @@
 #include <cstdio>
 #include <ctime>
 #include <fstream>
+#include <locale>
+#include <sstream>
 #include <optional>
 #include <stdexcept>
 
@@ -913,7 +915,8 @@ std::string lowerExtension(const std::string& path) {
 }
 
 bool isMultiObject(const std::string& ext) {
-    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
+    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".pov" || ext == ".wrl" ||
+           ext == ".x3d";
 }
 
 // The merged single mesh STL/OFF write, with the open shells kept.
@@ -1155,6 +1158,258 @@ void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies, c
 
 namespace {
 
+// The shortest decimal that reads back as exactly `v`, in the classic
+// locale (Qt sets the process locale from the environment, so printf could
+// write "1,5" on a German system and no DXF reader would take it). -0 is
+// written as 0, and a non-finite value -- which no contour should hold --
+// as 0 rather than as text a reader would choke on.
+std::string dxfNum(double v) {
+    if (!std::isfinite(v) || v == 0.0) return "0";
+    for (int digits = 6; digits <= 17; ++digits) {
+        std::ostringstream o;
+        o.imbue(std::locale::classic());
+        o.precision(digits);
+        o << v;
+        std::istringstream in(o.str());
+        in.imbue(std::locale::classic());
+        double back = 0.0;
+        in >> back;
+        if (back == v) return o.str();
+    }
+    std::ostringstream o;  // unreachable: 17 digits always round-trips a double
+    o.imbue(std::locale::classic());
+    o.precision(17);
+    o << v;
+    return o.str();
+}
+
+// The header, tables and (empty) blocks sections, verbatim from OpenSCAD's
+// export_dxf.cc -- its comments record which readers each piece was needed
+// for (Inkscape, LibreCAD, Illustrator, sharecad.org, generic cutters).
+void writeDxfHeader(std::ostream& out, double xMin, double yMin, double xMax, double yMax) {
+    out << "999\nDXF from OpenSCAD\n"
+        << "  0\nSECTION\n  2\nHEADER\n"
+        << "  9\n$ACADVER\n  1\nAC1006\n"
+        << "  9\n$INSBASE\n 10\n0.0\n 20\n0.0\n 30\n0.0\n";
+    for (const char* name : {"$EXTMIN", "$EXTMAX", "$LINMIN", "$LINMAX"}) {
+        const bool isMin = std::string(name).find("MIN") != std::string::npos;
+        out << "  9\n" << name << "\n 10\n" << dxfNum(isMin ? xMin : xMax) << "\n 20\n"
+            << dxfNum(isMin ? yMin : yMax) << "\n";
+    }
+    out << "  0\nENDSEC\n"
+        << "  0\nSECTION\n  2\nTABLES\n"
+        << "  0\nTABLE\n  2\nLTYPE\n 70\n1\n"
+        << "  0\nLTYPE\n  2\nCONTINUOUS\n 70\n64\n  3\nSolid line\n 72\n65\n 73\n0\n 40\n0.000000\n"
+        << "  0\nENDTAB\n"
+        << "  0\nTABLE\n  2\nLAYER\n 70\n6\n"
+        << "  0\nLAYER\n  2\n0\n 70\n64\n 62\n7\n  6\nCONTINUOUS\n"
+        << "  0\nENDTAB\n"
+        << "  0\nTABLE\n  2\nSTYLE\n 70\n0\n  0\nENDTAB\n"
+        << "  0\nENDSEC\n"
+        << "  0\nSECTION\n  2\nBLOCKS\n  0\nENDSEC\n";
+}
+
+} // namespace
+
+void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies) {
+    const Flat2d flat = collect2d(bodies);
+
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+    // The vertex counts go through the stream itself, which otherwise takes
+    // the global C++ locale -- one with digit grouping writes 1500 as "1.500".
+    out.imbue(std::locale::classic());
+
+    // Extents from collect2d's own bounding box. OpenSCAD starts its maxima
+    // at numeric_limits<double>::min() -- the smallest POSITIVE double, not
+    // the most negative -- so a model lying entirely at negative x or y gets
+    // a wrong $EXTMAX there. That is a bug, not a format rule.
+    writeDxfHeader(out, flat.minx, flat.miny, flat.maxx, flat.maxy);
+
+    out << "  0\nSECTION\n  2\nENTITIES\n";
+    for (const manifold::Polygons& polys : flat.perBody) {
+        for (const manifold::SimplePolygon& contour : polys) {
+            const auto xy = [&](const char* xCode, const char* yCode, const manifold::vec2& p) {
+                out << xCode << "\n" << dxfNum(p.x) << "\n" << yCode << "\n" << dxfNum(p.y) << "\n";
+            };
+            switch (contour.size()) {
+            case 0:
+                break;
+            case 1:
+                out << "  0\nPOINT\n100\nAcDbEntity\n  8\n0\n100\nAcDbPoint\n";
+                xy(" 10", " 20", contour[0]);
+                break;
+            case 2:
+                // [X1 Y1 X2 Y2]: the order ezdxf and dxfgrabber can read.
+                out << "  0\nLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbLine\n";
+                xy(" 10", " 20", contour[0]);
+                xy(" 11", " 21", contour[1]);
+                break;
+            default:
+                out << "  0\nLWPOLYLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbPolyline\n"
+                    << " 90\n" << contour.size() << "\n 70\n1\n";  // 70 = 1: closed
+                for (const manifold::vec2& p : contour) xy(" 10", " 20", p);
+            }
+        }
+    }
+    out << "  0\nENDSEC\n  0\nEOF\n";
+}
+
+namespace {
+
+// dxfNum's rule for a float: the shortest text that reads back as the same
+// float. Mesh vertices and colours are floats, and printing them as doubles
+// would turn 0.1f into 0.100000001490116.
+std::string floatNum(float v) {
+    if (!std::isfinite(v) || v == 0.0f) return "0";
+    for (int digits = 6; digits <= 9; ++digits) {
+        std::ostringstream o;
+        o.imbue(std::locale::classic());
+        o.precision(digits);
+        o << v;
+        std::istringstream in(o.str());
+        in.imbue(std::locale::classic());
+        float back = 0.0f;
+        in >> back;
+        if (back == v) return o.str();
+    }
+    std::ostringstream o;  // unreachable: 9 digits always round-trips a float
+    o.imbue(std::locale::classic());
+    o.precision(9);
+    o << v;
+    return o.str();
+}
+
+std::string povVec(double x, double y, double z) {
+    return "<" + dxfNum(x) + ", " + dxfNum(y) + ", " + dxfNum(z) + ">";
+}
+
+}  // namespace
+
+void writePov(const std::string& path, const std::vector<ExportObject>& objects, const ExportPovOptions& opts) {
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+    out.imbue(std::locale::classic());
+
+    out << "// Generated by BelfrySCAD (openscad_cpp_evaluator)\n\n"
+        << "// Camera settings are at the bottom of this script\n\n"
+        << "#version 3.7;\n"
+        << "global_settings { assumed_gamma 1.0 }\n"
+        << "#declare MATERIAL=finish { specular 0.5 roughness 0.001 reflection{0 0.63 fresnel} ambient 0 "
+           "diffuse 0.6 conserve_energy }\n"
+        << "#declare MATERIAL_INT=interior{ior 1.32}\n";
+
+    const auto rgbf = [](const std::array<float, 4>& c) {
+        return "<" + floatNum(c[0]) + ", " + floatNum(c[1]) + ", " + floatNum(c[2]) + ", " +
+               floatNum(1.0f - c[3]) + ">";
+    };
+
+    bool any = false;
+    double lo[3] = {0, 0, 0}, hi[3] = {0, 0, 0};
+    for (const ExportObject& o : objects) {
+        const size_t vertCount = o.verts.size() / 3;
+        const size_t triCount = o.tris.size() / 3;
+        if (vertCount == 0 || triCount == 0) continue;
+        for (size_t v = 0; v < vertCount; ++v) {
+            for (int k = 0; k < 3; ++k) {
+                const double c = o.verts[v * 3 + k];
+                if (!any) {
+                    lo[k] = hi[k] = c;
+                } else {
+                    lo[k] = std::min(lo[k], c);
+                    hi[k] = std::max(hi[k], c);
+                }
+            }
+            any = true;
+        }
+
+        // One texture per distinct colour, in order of first use.
+        std::vector<std::array<float, 4>> palette;
+        std::vector<size_t> triTexture(triCount, 0);
+        const auto textureOf = [&](const std::array<float, 4>& c) {
+            for (size_t i = 0; i < palette.size(); ++i) {
+                if (palette[i] == c) return i;
+            }
+            palette.push_back(c);
+            return palette.size() - 1;
+        };
+        for (size_t t = 0; t < triCount; ++t) {
+            triTexture[t] = textureOf(o.triColors.empty() ? o.color : o.triColors[t]);
+        }
+
+        out << "mesh2 {\n  vertex_vectors { " << vertCount;
+        for (size_t v = 0; v < vertCount; ++v) {
+            out << ",\n    <" << floatNum(o.verts[v * 3]) << ", " << floatNum(o.verts[v * 3 + 1]) << ", "
+                << floatNum(o.verts[v * 3 + 2]) << ">";
+        }
+        out << "\n  }\n  texture_list { " << palette.size();
+        for (const std::array<float, 4>& c : palette) {
+            out << "\n    texture { pigment { color rgbf " << rgbf(c) << " } finish { MATERIAL } }";
+        }
+        out << "\n  }\n  face_indices { " << triCount;
+        for (size_t t = 0; t < triCount; ++t) {
+            out << ",\n    <" << o.tris[t * 3] << ", " << o.tris[t * 3 + 1] << ", " << o.tris[t * 3 + 2] << ">, "
+                << triTexture[t];
+        }
+        // inside_vector: without it POV-Ray treats a mesh as a bare surface,
+        // with no inside for the interior (and its ior) or CSG to act on.
+        out << "\n  }\n  inside_vector <0, 0, 1>\n  interior { MATERIAL_INT }\n}\n";
+    }
+    if (!any) throw std::runtime_error("No geometry to export");
+
+    // 27 lights: every combination of {below, centre, above} on each axis,
+    // twice the model's size out, at OpenSCAD's brightness.
+    const double move = 2.0;
+    double at[3][3];
+    for (int k = 0; k < 3; ++k) {
+        const double d = hi[k] - lo[k];
+        at[k][0] = lo[k] - d * move;
+        at[k][1] = (lo[k] + hi[k]) / 2.0;
+        at[k][2] = hi[k] + d * move;
+    }
+    for (double x : at[0]) {
+        for (double y : at[1]) {
+            for (double z : at[2]) {
+                out << "light_source { " << povVec(x, y, z) << " color rgb <0.2, 0.2, 0.2> }\n";
+            }
+        }
+    }
+
+    if (opts.camera) {
+        // OpenSCAD's camera block, with two fixes, both checked by rendering
+        // in POV-Ray against BelfrySCAD's own image of the same camera:
+        //  - rotate BEFORE translate. The eye orbits $vpt, so it is rotated
+        //    about the origin and then moved; OpenSCAD translates first,
+        //    which rotates $vpt itself away and frames the wrong place
+        //    whenever a view both pans and turns.
+        //  - the field of view is VERTICAL in the viewport and HORIZONTAL to
+        //    POV-Ray's `angle`. OpenSCAD writes it straight across, so its
+        //    renders come out zoomed in by the aspect ratio (1.33x at 4:3).
+        //    The horizontal angle is left to POV-Ray to work out from the
+        //    image it is asked for, so any size frames the same.
+        const ExportPovCamera& c = *opts.camera;
+        out << "camera { look_at <0, 0, 0>\n"
+            << " location <0, 0, " << dxfNum(c.distance) << ">\n"
+            << " angle degrees(2 * atan(tan(radians(" << dxfNum(c.fov) << " / 2)) * image_width / image_height))"
+            << " up <0, 1, 0> right <1, 0, 0> sky <0, 1, 0> right -x*image_width/image_height\n"
+            << "rotate <" << dxfNum(c.vpr[0]) << ", " << dxfNum(c.vpr[1]) << " + clock * 3, " << dxfNum(c.vpr[2])
+            << " + clock>\n"
+            << "translate " << povVec(c.vpt[0], c.vpt[1], c.vpt[2]) << "\n"
+            << "}\n";
+    } else {
+        const double dx = hi[0] - lo[0], dy = hi[1] - lo[1], dz = hi[2] - lo[2];
+        out << "camera { look_at " << povVec((lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2)
+            << " location " << povVec(lo[0] + dx * move, lo[1] - dy * move, lo[2] + dz * move)
+            << " up <0, 0, 1> right <1, 0, 0> sky <0, 0, 1> rotate <-55, clock * 3, clock + 25> right "
+               "x*image_width/image_height }\n";
+    }
+    out << "#include \"rad_def.inc\"\n"
+        << "global_settings { photons { count 20000 autostop 0 jitter .4 } radiosity { "
+           "Rad_Settings(Radiosity_Normal, off, off) } }\n";
+}
+
+namespace {
+
 // PDF's own unit is 1/72 inch; models are millimetres.
 constexpr double kPtPerMm = 72.0 / 25.4;
 // Page margin the ruler is drawn on, in points. OpenSCAD's own MARGIN.
@@ -1497,8 +1752,8 @@ std::vector<std::string> writePdf(const std::string& path, const std::vector<Col
 }
 
 const std::vector<std::string>& exportExtensions() {
-    static const std::vector<std::string> exts = {".3mf", ".amf", ".pdf", ".stl", ".obj",
-                                                  ".off", ".ply", ".svg", ".wrl", ".x3d"};
+    static const std::vector<std::string> exts = {".3mf", ".amf", ".dxf", ".pdf", ".stl", ".obj",
+                                                  ".off", ".ply", ".pov", ".svg", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -1524,6 +1779,12 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         return writePdf(path, bodies, opts.pdf);
     }
 
+    if (ext == ".dxf") {
+        // 2D, outside the mesh pipeline like SVG and PDF.
+        writeDxf(path, bodies);
+        return warnings;
+    }
+
     if (ext == ".svg") {
         // 2D, and nothing the mesh pipeline below does applies: no merge,
         // no sliver strip, no manifoldness check. Contours are what they
@@ -1549,6 +1810,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
             writeObj(path, objects);
         } else if (ext == ".ply") {
             writePly(path, objects);
+        } else if (ext == ".pov") {
+            writePov(path, objects, opts.pov);
         } else if (ext == ".wrl") {
             writeVrml(path, objects);
         } else {