openscad-cpp-evaluator 1.38.0__tar.gz → 1.38.1__tar.gz

{openscad_cpp_evaluator-1.38.0 → openscad_cpp_evaluator-1.38.1}/PKG-INFO

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

{openscad_cpp_evaluator-1.38.0 → openscad_cpp_evaluator-1.38.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.38.0 → openscad_cpp_evaluator-1.38.1}/src/builtins/extrude.cpp

@@ -118,34 +118,86 @@ manifold::Manifold extrudeTwisted(const manifold::Polygons& polys, double height
 BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    // 100 when not given, as upstream (the old 1 was a guess), and `h` as
-    // upstream's alias -- BOSL2's linear_extrude override forwards it.
-    const double height = toDoubleLenient(getArgOrAlias(ev, &node.position(), args, 0, "height", "h", Value{100.0}));
-    const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
-    const double twist = toDoubleLenient(getArg(args, std::nullopt, "twist", Value{0.0}));
+    // Positional order is upstream's: height, v, scale, center, twist,
+    // slices, segments. Only height used to be read positionally.
+    //
+    // Upstream's LinearExtrudeNode: the extrusion runs along a vector, (0,0,1)
+    // unless `v` gives one. Its length is `height` (`h` its alias, BOSL2's
+    // override forwards it) when given -- `v` then only sets the direction --
+    // else |v| when `v` is given, else 100. A vector pointing down (z <= 0)
+    // extrudes nothing. Bad values warn and fall back as upstream's do.
+    // `v` was ignored here, so an oblique extrusion came out straight.
+    double hv[3] = {0.0, 0.0, 1.0};
+    double length = 100.0;
+    const Value vArg = getArg(args, 1, "v", Value{});
+    if (!std::holds_alternative<std::monostate>(vArg)) {
+        const ListPtr* l = std::get_if<ListPtr>(&vArg);
+        bool ok = l && *l && (*l)->items.size() == 3;
+        double t[3] = {0, 0, 0};
+        for (int i = 0; ok && i < 3; ++i) {
+            const double* d = std::get_if<double>(&(*l)->items[i]);
+            ok = d && std::isfinite(*d);
+            if (ok) t[i] = *d;
+        }
+        if (ok) std::copy(t, t + 3, hv);
+        else ev.warn("v when specified should be a 3d vector", &node.position());
+        length = 1.0;
+    }
+    const Value heightArg = getArgOrAlias(ev, &node.position(), args, 0, "height", "h", Value{});
+    if (!std::holds_alternative<std::monostate>(heightArg)) {
+        const double* d = std::get_if<double>(&heightArg);
+        if (d && std::isfinite(*d)) {
+            length = *d;
+        } else {
+            ev.warn("height when specified should be a number", &node.position());
+            length = 100.0;
+        }
+        const double norm = std::sqrt(hv[0] * hv[0] + hv[1] * hv[1] + hv[2] * hv[2]);
+        for (double& c : hv) c /= norm;
+    }
+    for (double& c : hv) c *= length;
+    if (hv[2] <= 0) hv[2] = 0;
+    const double height = hv[2];
+    // Only a real boolean counts, as upstream: center="yes" is not true.
+    const Value centerArg = getArg(args, 3, "center", Value{false});
+    const bool* centerBool = std::get_if<bool>(&centerArg);
+    const bool center = centerBool && *centerBool;
+    const double twist = toDoubleLenient(getArg(args, 4, "twist", Value{0.0}));
     // Upstream's validate_integral: any finite number counts as given, and is
     // truncated and clamped (slices >= 1, segments >= 0). Not given, the
     // discretizer decides.
-    const auto integral = [&](const char* name, double lo) -> std::optional<double> {
-        const Value v = getArg(args, std::nullopt, name, Value{});
+    const auto integral = [&](int pos, const char* name, double lo) -> std::optional<double> {
+        const Value v = getArg(args, pos, name, Value{});
         const double* d = std::get_if<double>(&v);
         if (!d || !std::isfinite(*d)) return std::nullopt;
         return *d < lo ? lo : std::trunc(*d);
     };
-    const std::optional<double> slices = integral("slices", 1.0);
-    const std::optional<double> segments = integral("segments", 0.0);
-    const Value scaleArg = getArg(args, std::nullopt, "scale", Value{});
+    const std::optional<double> slices = integral(5, "slices", 1.0);
+    const std::optional<double> segments = integral(6, "segments", 0.0);
+    const Value scaleArg = getArg(args, 2, "scale", Value{});
 
     double scaleX = 1.0, scaleY = 1.0;
+    bool scaleOk = true;
     if (const double* s = std::get_if<double>(&scaleArg)) {
         scaleX = scaleY = *s;
+        scaleOk = std::isfinite(*s);
     } else if (const ListPtr* l = std::get_if<ListPtr>(&scaleArg); l && *l && (*l)->items.size() >= 2) {
         scaleX = toDoubleLenient((*l)->items[0]);
         scaleY = toDoubleLenient((*l)->items[1]);
+        scaleOk = std::isfinite(scaleX) && std::isfinite(scaleY);
+    } else if (!std::holds_alternative<std::monostate>(scaleArg)) {
+        scaleOk = false;
+    }
+    if (!scaleOk) {
+        ev.warn("linear_extrude(..., scale=" + fmtValue(scaleArg) + ") could not be converted", &node.position());
+        scaleX = scaleY = 1.0;
     }
 
     CSGParams params;
     params["height"] = Value{height};
+    // How far the top slides sideways per unit of height (0 unless `v`).
+    params["shear_x"] = Value{height > 0 ? hv[0] / height : 0.0};
+    params["shear_y"] = Value{height > 0 ? hv[1] / height : 0.0};
     params["center"] = Value{center};
     params["twist"] = Value{twist};
     params["slices"] = slices ? Value{*slices} : Value{};
@@ -227,6 +279,14 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
             ? extrudeTwisted(polys, height, slices, twist, scaleX, scaleY)
             : manifold::Manifold::Extrude(polys, height, slices - 1, -twist, manifold::vec2(scaleX, scaleY));
     if (std::get<bool>(params.at("center"))) body = body.Translate(manifold::vec3(0, 0, -height / 2));
+    // `v`: slide each point sideways in proportion to its height -- upstream
+    // places slice k at bottom + v*k/n, and centring subtracts v/2, so the
+    // same shear is right either way.
+    const double shearX = std::get<double>(params.at("shear_x"));
+    const double shearY = std::get<double>(params.at("shear_y"));
+    if (shearX != 0.0 || shearY != 0.0) {
+        body = body.Transform(manifold::mat3x4({1, 0, 0}, {0, 1, 0}, {shearX, shearY, 1}, {0, 0, 0}));
+    }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 
@@ -241,11 +301,36 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
 BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    const double angle = toDoubleLenient(getArgOrAlias(ev, &node.position(), args, 0, "angle", "a", Value{360.0}));
+    // Positional order is upstream's: angle, start.
+    //
+    // Upstream's RotateExtrudeNode: the sweep runs from `start` through
+    // `start + angle`. With an angle, start defaults to 0 (the +X axis) and
+    // an angle outside (-360, 360] becomes a full turn; with none, the turn
+    // is 360 and starts at 180 (-X), which upstream says will change, and
+    // says so for an odd $fn, where the start shows. An explicit start
+    // always wins. It was ignored here: a quarter turn from 90 drew 0..90.
+    const Value angleArg = getArgOrAlias(ev, &node.position(), args, 0, "angle", "a", Value{});
+    const Value startArg = getArg(args, 1, "start", Value{});
+    const bool hasAngle = !std::holds_alternative<std::monostate>(angleArg) && std::isfinite(toDoubleLenient(angleArg));
+    const bool hasStart = !std::holds_alternative<std::monostate>(startArg) && std::isfinite(toDoubleLenient(startArg));
+    double angle = 360.0;
+    double start = 180.0;
+    if (hasAngle) {
+        angle = toDoubleLenient(angleArg);
+        start = 0.0;
+        if (angle <= -360.0 || angle > 360.0) angle = 360.0;
+    }
+    if (hasStart) start = toDoubleLenient(startArg);
+    const Discretizer disc = Discretizer::fromCtx(effCtx);
+    if (!hasAngle && !hasStart && (static_cast<int>(disc.fn) & 1)) {
+        ev.emitWarning("DEPRECATED: In future releases, rotational extrusion without \"angle\" will start at zero, "
+                       "the +X axis.  Set start=180 to explicitly start on the -X axis.");
+    }
 
     CSGParams params;
     params["angle"] = Value{angle};
-    Discretizer::fromCtx(effCtx).store(params);
+    params["start"] = Value{start};
+    disc.store(params);
     params["color"] = colorToValue(effCtx.color);
     return BuiltinWrapParams{std::move(params), std::move(effCtx)};
 }
@@ -299,6 +384,9 @@ std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& p
             v = manifold::vec3(v.x * std::cos(a), v.x * std::sin(a), sign * v.y);
         });
     }
+    // The arc above runs from +X; turn it to begin at `start`.
+    const double start = std::get<double>(params.at("start"));
+    if (start != 0.0) body = body.Rotate(0.0, 0.0, start);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 

{openscad_cpp_evaluator-1.38.0 → openscad_cpp_evaluator-1.38.1}/tests/test_extrude_roof.cpp

@@ -82,6 +82,85 @@ TEST(LinearExtrude, ScaleShrinksTheTopFace) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), straight / 3.0, straight * 0.02);
 }
 
+// linear_extrude's `v`, and its argument checks, as upstream's
+// LinearExtrudeNode has them; each case below matched OpenSCAD 2026.02's
+// bounding box and volume. `v` was ignored here before.
+namespace {
+struct Extruded {
+    manifold::Box box;
+    double volume = 0;
+    std::vector<std::string> msgs;
+};
+Extruded linearExtrude(const std::string& args) {
+    Extruded r;
+    Evaluated e = evalSrc("linear_extrude(" + args + ") translate([5,0]) square([4,2]);",
+                          [&](const std::string& m) { r.msgs.push_back(m); });
+    if (!e.bodies.empty() && e.bodies[0].body) {
+        r.box = e.bodies[0].body->BoundingBox();
+        r.volume = e.bodies[0].body->Volume();
+    }
+    return r;
+}
+} // namespace
+
+TEST(LinearExtrude, VAloneIsTheWholeExtrusion) {
+    const Extruded r = linearExtrude("v=[1,0,1]");  // length |v|, leaning +X
+    EXPECT_NEAR(r.box.max.x, 10.0, 1e-6);
+    EXPECT_NEAR(r.box.max.z, 1.0, 1e-6);
+    EXPECT_NEAR(r.volume, 8.0, 1e-6);
+}
+
+TEST(LinearExtrude, HeightWithVSetsOnlyTheDirection) {
+    const Extruded r = linearExtrude("v=[1,1,1], height=10");
+    const double side = 10.0 / std::sqrt(3.0);
+    EXPECT_NEAR(r.box.max.x, 9.0 + side, 1e-3);
+    EXPECT_NEAR(r.box.max.y, 2.0 + side, 1e-3);
+    EXPECT_NEAR(r.box.max.z, side, 1e-3);
+}
+
+TEST(LinearExtrude, CenteringShiftsByHalfOfV) {
+    const Extruded r = linearExtrude("v=[2,3,10], center=true");
+    EXPECT_NEAR(r.box.min.x, 4.0, 1e-6);
+    EXPECT_NEAR(r.box.max.x, 10.0, 1e-6);
+    EXPECT_NEAR(r.box.min.y, -1.5, 1e-6);
+    EXPECT_NEAR(r.box.min.z, -5.0, 1e-6);
+}
+
+TEST(LinearExtrude, DownwardVExtrudesNothing) {
+    EXPECT_EQ(linearExtrude("v=[0,0,-1]").volume, 0.0);
+}
+
+TEST(LinearExtrude, OnlyARealBooleanCenters) {
+    EXPECT_NEAR(linearExtrude("height=10, center=\"yes\"").box.min.z, 0.0, 1e-6);
+    EXPECT_NEAR(linearExtrude("height=10, center=true").box.min.z, -5.0, 1e-6);
+}
+
+TEST(LinearExtrude, BadArgumentsWarnAndFallBack) {
+    const Extruded h = linearExtrude("height=\"a\"");
+    EXPECT_NEAR(h.box.max.z, 100.0, 1e-6);
+    ASSERT_EQ(h.msgs.size(), 1u);
+    EXPECT_EQ(h.msgs[0].rfind("WARNING: height when specified should be a number", 0), 0u) << h.msgs[0];
+
+    const Extruded v = linearExtrude("v=[1,2]");
+    EXPECT_NEAR(v.box.max.z, 1.0, 1e-6);
+    ASSERT_EQ(v.msgs.size(), 1u);
+    EXPECT_EQ(v.msgs[0].rfind("WARNING: v when specified should be a 3d vector", 0), 0u) << v.msgs[0];
+
+    const Extruded s = linearExtrude("height=10, scale=\"x\"");
+    EXPECT_NEAR(s.volume, 80.0, 1e-6);
+    ASSERT_EQ(s.msgs.size(), 1u);
+    EXPECT_EQ(s.msgs[0].rfind("WARNING: linear_extrude(..., scale=\"x\") could not be converted", 0), 0u) << s.msgs[0];
+}
+
+TEST(LinearExtrude, ArgumentsArePositionalInUpstreamsOrder) {
+    // height, v, scale, center, twist, slices, segments
+    EXPECT_NEAR(linearExtrude("10, [1,0,1]").box.max.x, 9.0 + 10.0 / std::sqrt(2.0), 1e-3);
+    EXPECT_NEAR(linearExtrude("10, undef, 0.5").volume, 46.67, 0.01);
+    EXPECT_NEAR(linearExtrude("10, undef, 1, true").box.min.z, -5.0, 1e-6);
+    EXPECT_NEAR(linearExtrude("10, undef, 1, false, 90").box.min.y, -9.0, 1e-6);
+    EXPECT_NEAR(linearExtrude("10, undef, 1, false, 90, 2").volume, 81.62, 0.01);
+}
+
 // -- rotate_extrude -----------------------------------------------------
 
 TEST(RotateExtrude, FullRevolveOfASquareMatchesPappusTheorem) {
@@ -96,6 +175,56 @@ TEST(RotateExtrude, FullRevolveOfASquareMatchesPappusTheorem) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), analytic, analytic * 0.01);
 }
 
+// The sweep runs from `start` through start + angle, as upstream's
+// RotateExtrudeNode has it; start was ignored here until this was checked
+// against OpenSCAD 2026.02 (every case below matched it bounding box for
+// bounding box).
+namespace {
+manifold::Box rotateExtrudeBox(const std::string& args, std::vector<std::string>* msgs = nullptr) {
+    Evaluated e = evalSrc("rotate_extrude(" + args + ") translate([10,0]) square(2);",
+                          [&](const std::string& m) { if (msgs) msgs->push_back(m); });
+    EXPECT_EQ(e.bodies.size(), 1u);
+    return e.bodies.empty() ? manifold::Box{} : e.bodies[0].body->BoundingBox();
+}
+} // namespace
+
+TEST(RotateExtrude, StartTurnsWhereTheSweepBegins) {
+    const manifold::Box b = rotateExtrudeBox("angle=90, start=90");  // the +Y/-X quadrant
+    EXPECT_NEAR(b.min.x, -12.0, 1e-6);
+    EXPECT_NEAR(b.max.x, 0.0, 1e-6);
+    EXPECT_NEAR(b.min.y, 0.0, 1e-6);
+    const manifold::Box neg = rotateExtrudeBox("angle=-90, start=90");  // sweeps back to +X
+    EXPECT_NEAR(neg.min.x, 0.0, 1e-6);
+    EXPECT_NEAR(neg.min.y, 0.0, 1e-6);
+    EXPECT_NEAR(neg.max.y, 12.0, 1e-6);
+}
+
+TEST(RotateExtrude, AFullTurnWithNoAngleStartsOnMinusXAndSaysItWillChange) {
+    std::vector<std::string> msgs;
+    const manifold::Box b = rotateExtrudeBox("$fn=5", &msgs);  // a pentagon: the start shows
+    EXPECT_NEAR(b.min.x, -12.0, 1e-6);
+    EXPECT_NEAR(b.max.x, 12.0 * std::cos(std::numbers::pi / 5), 1e-3);
+    ASSERT_EQ(msgs.size(), 1u);
+    EXPECT_EQ(msgs[0].rfind("DEPRECATED: In future releases, rotational extrusion without \"angle\"", 0), 0u) << msgs[0];
+    // Given an angle or a start, it starts where told and says nothing.
+    msgs.clear();
+    EXPECT_NEAR(rotateExtrudeBox("angle=360, $fn=5", &msgs).max.x, 12.0, 1e-6);
+    EXPECT_NEAR(rotateExtrudeBox("start=0, $fn=5", &msgs).max.x, 12.0, 1e-6);
+    EXPECT_TRUE(msgs.empty());
+}
+
+TEST(RotateExtrude, StartIsTheSecondPositionalArgument) {
+    EXPECT_NEAR(rotateExtrudeBox("90, 90").min.x, -12.0, 1e-6);  // angle, start
+}
+
+TEST(RotateExtrude, AnAngleOutsideAFullTurnIsAFullTurn) {
+    for (const char* a : {"angle=400", "angle=-400", "angle=-360"}) {
+        const manifold::Box b = rotateExtrudeBox(a);
+        EXPECT_NEAR(b.min.x, -12.0, 1e-3) << a;
+        EXPECT_NEAR(b.max.x, 12.0, 1e-3) << a;
+    }
+}
+
 // -- projection -----------------------------------------------------------
 
 TEST(Projection, NonCutProjectsFullSilhouette) {

{openscad_cpp_evaluator-1.38.0 → openscad_cpp_evaluator-1.38.1}/uv.lock

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