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

{openscad_cpp_evaluator-1.32.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 eleven
-  formats `exportExtensions()` lists: 3MF, AMF, DXF, 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,20 @@ 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

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

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

{openscad_cpp_evaluator-1.32.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.32.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>
 
@@ -233,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;
@@ -258,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.32.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.32.0"
+version = "1.33.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.32.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.32.0 → openscad_cpp_evaluator-1.33.0}/src/export.cpp

@@ -915,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.
@@ -1256,6 +1257,159 @@ void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies) {
 
 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.
@@ -1599,7 +1753,7 @@ 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", ".dxf", ".pdf", ".stl", ".obj",
-                                                  ".off", ".ply", ".svg", ".wrl", ".x3d"};
+                                                  ".off", ".ply", ".pov", ".svg", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -1656,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 {

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.33.0}/tests/test_export.cpp

@@ -569,6 +569,124 @@ TEST(ExportDxf, ReachableThroughExportModelAndListedAsAnExtension) {
     std::remove(path.c_str());
 }
 
+// -- POV-Ray (mesh2) -------------------------------------------------------
+
+namespace {
+
+std::string povOf(const std::string& code, const std::string& name, const ExportOptions& opts = {}) {
+    const std::string path = tempPath(name).string();
+    ExportOptions o = opts;
+    o.format = ".pov";
+    exportModel(path, evalToBodies(code), o);
+    const std::string text = readText(path);
+    std::remove(path.c_str());
+    return text;
+}
+
+// The block following `header` up to and including its matching "}" line --
+// crude, but every block this writer emits closes on a line of its own.
+std::string povBlock(const std::string& text, const std::string& header, size_t from = 0) {
+    const size_t at = text.find(header, from);
+    if (at == std::string::npos) return "";
+    const size_t end = text.find("\n  }", at);
+    return text.substr(at, end == std::string::npos ? std::string::npos : end - at);
+}
+
+} // namespace
+
+// One mesh2 per exported object -- here one per colour -- with a welded
+// vertex list (a cube is 8 vertices, not 36), 12 triangles, and the
+// inside_vector that makes POV-Ray treat it as a solid rather than a
+// surface. OpenSCAD writes the same scene as 12 separate polygon objects.
+TEST(ExportPov, OneWeldedSolidMesh2PerObject) {
+    const std::string text = povOf(
+        "color([1, 0.5, 0.25, 0.125]) translate([-10, 0, 0]) cube(10);\n"
+        "color(\"green\") translate([10, 0, 0]) cube(10);", "two.pov");
+    EXPECT_EQ(countOf(text, "mesh2 {"), 2u);
+    EXPECT_EQ(countOf(text, "polygon {"), 0u);
+    EXPECT_EQ(countOf(text, "vertex_vectors { 8,"), 2u);
+    EXPECT_EQ(countOf(text, "face_indices { 12,"), 2u);
+    EXPECT_EQ(countOf(text, "inside_vector <0, 0, 1>"), 2u);
+    // rgbf with filter = 1 - alpha, as OpenSCAD writes colour.
+    EXPECT_NE(text.find("color rgbf <1, 0.5, 0.25, 0.875>"), std::string::npos);
+    EXPECT_NE(text.find("#version 3.7;"), std::string::npos);
+    EXPECT_NE(text.find("#include \"rad_def.inc\""), std::string::npos);
+}
+
+// Per-triangle colour -- a CSG merge of two colours -- is a texture_list
+// with one entry per colour and a texture index on each triangle. The mesh
+// stays welded; PLY, by contrast, has to unweld to colour a triangle.
+TEST(ExportPov, PerTriangleColourIsATextureIndexNotAnUnweld) {
+    const std::string text =
+        povOf("color(\"red\") difference() { cube(20, center=true); color(\"blue\") sphere(13, $fn=24); }",
+              "tricolor.pov");
+    EXPECT_EQ(countOf(text, "mesh2 {"), 1u);
+    const std::string textures = povBlock(text, "texture_list {");
+    EXPECT_NE(textures.find("texture_list { 2"), std::string::npos);
+    EXPECT_NE(textures.find("rgbf <1, 0, 0, 0>"), std::string::npos);
+    EXPECT_NE(textures.find("rgbf <0, 0, 1, 0>"), std::string::npos);
+    const std::string faces = povBlock(text, "face_indices {");
+    EXPECT_NE(faces.find(">, 0"), std::string::npos);
+    EXPECT_NE(faces.find(">, 1"), std::string::npos);
+}
+
+// Checked by rendering in POV-Ray 3.7 against BelfrySCAD's own PNG of the
+// same camera, which agreed to a pixel. Two departures from OpenSCAD make
+// that true: rotate comes BEFORE translate (the eye orbits $vpt), and the
+// viewport's VERTICAL fov is turned into POV-Ray's HORIZONTAL angle from
+// the image's own aspect ratio.
+TEST(ExportPov, CameraOrbitsVptAndKeepsTheVerticalFieldOfView) {
+    ExportOptions opts;
+    opts.pov.camera = ExportPovCamera{{0, 5, 5}, {55, 0, 25}, 140, 22.5};
+    const std::string text = povOf("cube(10);", "camera.pov", opts);
+    const size_t cam = text.find("camera {");
+    ASSERT_NE(cam, std::string::npos);
+    const std::string block = text.substr(cam, text.find("\n}\n", cam) - cam);
+    EXPECT_NE(block.find(" location <0, 0, 140>"), std::string::npos);
+    EXPECT_NE(block.find("angle degrees(2 * atan(tan(radians(22.5 / 2)) * image_width / image_height))"),
+              std::string::npos);
+    const size_t rotate = block.find("rotate <55, 0 + clock * 3, 25 + clock>");
+    const size_t translate = block.find("translate <0, 5, 5>");
+    ASSERT_NE(rotate, std::string::npos);
+    ASSERT_NE(translate, std::string::npos);
+    EXPECT_LT(rotate, translate);
+}
+
+TEST(ExportPov, WithoutACameraFramesTheBoundingBoxAsOpenscadDoes) {
+    const std::string text = povOf("translate([-10, 0, 0]) cube([30, 10, 10]);", "nocam.pov");
+    EXPECT_NE(text.find("camera { look_at <5, 5, 5> location <50, -20, 20> up <0, 0, 1>"), std::string::npos);
+    // 27 lights: below, at and beyond the box on every axis.
+    EXPECT_EQ(countOf(text, "light_source {"), 27u);
+    EXPECT_NE(text.find("light_source { <-70, -20, -20> color rgb <0.2, 0.2, 0.2> }"), std::string::npos);
+}
+
+TEST(ExportPov, NumbersIgnoreTheGlobalLocale) {
+    const std::locale previous = std::locale::global(std::locale(std::locale::classic(), new GermanishPunct));
+    std::string text;
+    try {
+        text = povOf("translate([0.5, 0, 0]) sphere(10, $fn=64);", "locale.pov");
+    } catch (...) {
+        std::locale::global(previous);
+        throw;
+    }
+    std::locale::global(previous);
+    const std::string verts = povBlock(text, "vertex_vectors {");
+    ASSERT_FALSE(verts.empty());
+    const int count = std::stoi(verts.substr(std::string("vertex_vectors { ").size()));
+    EXPECT_GT(count, 1000);                                     // so grouping would show
+    EXPECT_EQ(verts.find('.', 0) < verts.find('\n') ? 1 : 0, 0); // the count has no separator
+    EXPECT_EQ(text.find("0,5"), std::string::npos);              // no decimal commas anywhere
+}
+
+TEST(ExportPov, ReachableThroughExportModelAndListedAsAnExtension) {
+    const std::vector<std::string>& exts = exportExtensions();
+    EXPECT_NE(std::find(exts.begin(), exts.end(), ".pov"), exts.end());
+    const std::string path = tempPath("via_export_model.pov").string();
+    EXPECT_TRUE(exportModel(path, evalToBodies("cube(5);"), ExportOptions{}).empty());
+    EXPECT_EQ(countOf(readText(path), "mesh2 {"), 1u);
+    std::remove(path.c_str());
+}
+
 // -- PDF (2D) --------------------------------------------------------------
 
 namespace {

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.33.0}/tests/test_python_bindings.py

@@ -747,6 +747,40 @@ def test_export_model_dxf_refuses_a_3d_model(tmp_path):
         export_model(str(tmp_path / "solid.dxf"), ev.geometry)
 
 
+def test_export_model_writes_pov_mesh2_with_the_viewport_camera(tmp_path):
+    """.pov through the facade: one solid mesh2 per object, and pov_camera
+    ($vpt, $vpr, distance, fov) reaching the camera block."""
+    from openscad_cpp_evaluator import Evaluator, export_extensions, export_model
+
+    assert ".pov" in export_extensions()
+    src = tmp_path / "scene.scad"
+    src.write_text('color("red") cube(10); color("green") translate([20, 0, 0]) cube(10);')
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    out = tmp_path / "scene.pov"
+    assert export_model(str(out), ev.geometry, pov_camera=[1, 2, 3, 55, 0, 25, 140, 22.5]) == []
+    text = out.read_text()
+    assert text.count("mesh2 {") == 2 and text.count("inside_vector <0, 0, 1>") == 2
+    assert "rotate <55, 0 + clock * 3, 25 + clock>\ntranslate <1, 2, 3>" in text
+    assert "location <0, 0, 140>" in text
+
+    bare = tmp_path / "bare.pov"
+    export_model(str(bare), ev.geometry)
+    assert "rotate <-55, clock * 3, clock + 25>" in bare.read_text()   # the bounding-box camera
+
+
+def test_export_model_pov_camera_needs_eight_numbers(tmp_path):
+    from openscad_cpp_evaluator import Evaluator, EvalError, export_model
+
+    src = tmp_path / "c.scad"
+    src.write_text("cube(1);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+    with pytest.raises(EvalError, match="8 numbers"):
+        export_model(str(tmp_path / "c.pov"), ev.geometry, pov_camera=[0, 0, 0])
+
+
 def test_export_model_writes_pdf_and_takes_its_options(tmp_path):
     """.pdf through the facade, plus the option dict. Same
     two-parameter-list trap as split_components and the svg_* set."""

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.33.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.32.0"
+version = "1.33.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },