fix: a failing fillet/chamfer and a failing ql exactly() attach their evidence picture again
2.2.6 drew one picture for each (the failing edge as an orange line; the matched faces orange and the near misses purple). The native port attached none, and the old test file that asserts them was one of those the port deleted. - BlendDiagnosis carries the edges and the caption of the six probes (the old ones); raise_blend_failure asks for the picture through DiagnosticImage (new field highlight_edges), the provider call gets the edges. - evidence.py draws it, and the ql picture through the existing ql evidence hook, on a clone of the scope: the user's shape is not tagged. - test_error_diagnostics_blend_ql.py is restored (13 tests). 12 pass; test_ql_evidence_highlight_is_visible is listed as open: the picture is right but the soft renderer's shading leaves 302 sampled orange pixels where the test asks for more than 400. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -460,15 +460,17 @@ void bind_sdk_compat(py::module_& m) {
|
||||
const auto callable = std::make_shared<KeptCallable>(provider);
|
||||
set_diagnostic_image_provider([callable](const DiagnosticImage& request) -> std::optional<ErrorEvidence> {
|
||||
const py::gil_scoped_acquire gil; // the operation that failed may be running without the GIL
|
||||
py::list shapes;
|
||||
py::list shapes, highlight_edges;
|
||||
for (const Shape& shape : request.shapes) shapes.append(scad::pybind::reactive::shape_to_python(shape));
|
||||
for (const Shape& edge : request.highlight_edges) highlight_edges.append(scad::pybind::reactive::shape_to_python(edge));
|
||||
const py::object picture = callable->get()(request.kind, request.operation, request.view, request.caption,
|
||||
request.dedup_key, shapes, scad::pybind::value_to_python(request.payload));
|
||||
request.dedup_key, shapes, scad::pybind::value_to_python(request.payload),
|
||||
highlight_edges);
|
||||
if (picture.is_none()) return std::nullopt;
|
||||
return evidence_of(picture);
|
||||
});
|
||||
}, py::arg("provider"),
|
||||
"Install provider(kind, operation, view, caption, dedup_key, shapes, payload) -> evidence dict or None: it "
|
||||
"Install provider(kind, operation, view, caption, dedup_key, shapes, payload, highlight_edges) -> evidence dict or None: it "
|
||||
"draws the pictures a failing operation asks for. None removes it.");
|
||||
m.def("_sample_edge_points", [](const Shape& edge, int samples) {
|
||||
if (edge.kind() != Kind::Edge) throw TypeError("_sample_edge_points needs an Edge");
|
||||
|
||||
@@ -67,6 +67,7 @@ so assemblies had no data flow in the graph. Done, all additive:
|
||||
| native, ids/refs canonical | 1927 | 181 | 11 | `reserve_node`, resolved topology refs, dataclass protocol |
|
||||
| native, current (run 5) | 1942 | 170 | 11 | scene/apiindex fixes |
|
||||
| native, current with the classification of `test/native_known_failures.json` (run 6) | 1942 (+351 subtests) | 0 unexpected | 3 (same as ocp) | 46 skipped as internal, 122 xfailed as open, 8 modules ignored at collection (private helpers); 2231 -> 1942 passed, 289 of the baseline's passes are internal or open |
|
||||
| native, 2026-10-29 (`feat/sca-serve`; the rows above are history) | 2197 | 0 | 0 | 49 skipped (19 internal in `test/native_known_failures.json`, the rest optional packages), 1 xfailed (`open`: the soft renderer's shading of the ql evidence picture), 7 restored old test files not yet tracked (need bindings); `src/cpp/tests/python` 468 passed |
|
||||
|
||||
Failures by cause (run 5, 170):
|
||||
1. the SDK's graph replay contract (`replay_model_json` / `replay_graph`; ~85): native-recorded nodes differ from
|
||||
|
||||
@@ -27,6 +27,8 @@ struct BlendDiagnosis {
|
||||
std::vector<std::string> possible_causes;
|
||||
std::vector<ErrorMeasurement> measurements;
|
||||
std::vector<std::string> repair;
|
||||
std::vector<Edge> evidence_edges; // the edges the picture marks as orange lines
|
||||
std::string evidence_caption;
|
||||
};
|
||||
|
||||
// Does the blend succeed on this one edge alone? The per-edge diagnostic rerun.
|
||||
|
||||
@@ -23,6 +23,7 @@ struct DiagnosticImage {
|
||||
std::string caption;
|
||||
std::string dedup_key; // the same failure is drawn once per process
|
||||
std::vector<Shape> shapes; // what to draw (3D kinds, and the wires of the plans)
|
||||
std::vector<Shape> highlight_edges; // edges of `shapes` a 3D picture draws as orange lines
|
||||
Value payload = Value::object(); // kind-specific data: marks, labels, entities, what is implicated
|
||||
};
|
||||
|
||||
|
||||
@@ -86,9 +86,13 @@ std::optional<BlendDiagnosis> classify_tiny_edges(const Case& c) {
|
||||
const double threshold = std::max(1e-3, median * 1e-3); // sub-micron slivers against the selection's scale
|
||||
std::size_t tiny = 0;
|
||||
double shortest = 0.0;
|
||||
const Edge* shortest_edge = nullptr;
|
||||
for (const auto& entry : lengths) {
|
||||
if (entry.second > threshold) continue;
|
||||
shortest = tiny == 0 ? entry.second : std::min(shortest, entry.second);
|
||||
if (tiny == 0 || entry.second < shortest) {
|
||||
shortest = entry.second;
|
||||
shortest_edge = entry.first;
|
||||
}
|
||||
++tiny;
|
||||
}
|
||||
if (tiny == 0 || tiny == lengths.size()) return std::nullopt;
|
||||
@@ -103,6 +107,8 @@ std::optional<BlendDiagnosis> classify_tiny_edges(const Case& c) {
|
||||
out.measurements = {{"shortest_selected_edge", shortest, "mm"}, {"selection_median_edge", median, "mm"}};
|
||||
out.repair = {"Drop the sliver edges from the selection (filter by feature intent, not by a blanket selector).",
|
||||
"Re-select with a QL predicate that excludes sub-micron edges before the " + c.words.blend + "."};
|
||||
out.evidence_edges = {*shortest_edge};
|
||||
out.evidence_caption = "orange line marks the shortest sliver edge; see measurements";
|
||||
return out;
|
||||
}
|
||||
|
||||
@@ -126,6 +132,8 @@ std::optional<BlendDiagnosis> classify_tangent_adjacency(const Case& c) {
|
||||
out.repair = {"Remove that junction edge from the selection: there is no corner to blend.",
|
||||
"If a visual transition is required there, it already exists \xE2\x80\x94 the faces are tangent by "
|
||||
"construction."};
|
||||
out.evidence_edges = {edge};
|
||||
out.evidence_caption = "orange line marks the tangent junction edge; see measurements";
|
||||
return out;
|
||||
}
|
||||
return std::nullopt;
|
||||
@@ -151,6 +159,9 @@ std::optional<BlendDiagnosis> classify_blend_room(const Case& c) {
|
||||
out.repair = {"Reduce the " + c.words.size + " to below " + g4(*extent) + " mm (e.g. " + g4(*extent * 0.95) +
|
||||
") and retry.",
|
||||
"Or select a different edge with more room on its adjacent faces."};
|
||||
out.evidence_edges = {edge};
|
||||
out.evidence_caption =
|
||||
"orange line marks the failing edge; see measurements for its endpoints and the available face room";
|
||||
return out;
|
||||
}
|
||||
}
|
||||
@@ -185,6 +196,8 @@ std::optional<BlendDiagnosis> classify_partial_smooth_chain(const Case& c) {
|
||||
out.repair = {"Select the entire smooth chain: every tangent-continuous segment of that curve, then blend them "
|
||||
"together in one call.",
|
||||
"Enumerate with QL and extend the selection across the shared vertices before retrying."};
|
||||
out.evidence_edges = {edge};
|
||||
out.evidence_caption = "orange line marks the partially selected chain segment";
|
||||
return out;
|
||||
}
|
||||
}
|
||||
@@ -207,6 +220,8 @@ BlendDiagnosis tangency_critical(const Case& c, const Edge& edge, double extent)
|
||||
out.repair = {"Reduce the " + c.words.size + " below " + g4(extent / 2) +
|
||||
" mm (half the narrowest shared face) so adjacent blend surfaces leave material between them.",
|
||||
"Or blend the edges in two passes with different sizes."};
|
||||
out.evidence_edges = {edge};
|
||||
out.evidence_caption = "orange line marks the critical edge; see measurements";
|
||||
return out;
|
||||
}
|
||||
|
||||
@@ -262,6 +277,8 @@ std::optional<BlendDiagnosis> classify_vertex_conflict(const Case& c) {
|
||||
out.repair = {"Blend the converging edges in separate passes: hardest edges first, then the remainder with a "
|
||||
"smaller size.",
|
||||
"Or drop the corner edge from this pass and blend it alone afterwards."};
|
||||
for (std::size_t i = 0; i < corner.incident.size() && i < 3; ++i) out.evidence_edges.push_back(*corner.incident[i]);
|
||||
out.evidence_caption = "orange lines mark the edges converging at the corner vertex";
|
||||
return out;
|
||||
}
|
||||
return std::nullopt;
|
||||
|
||||
@@ -3,11 +3,13 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <functional>
|
||||
|
||||
#include "internal.hpp"
|
||||
#include "scad/ops/features/diagnostics.hpp"
|
||||
#include "scad/semantic/tracking.hpp"
|
||||
#include "scad/topo/diagnostic_image.hpp"
|
||||
|
||||
namespace scad {
|
||||
|
||||
@@ -53,6 +55,22 @@ raise_blend_failure(const ErrorSpec &base, const std::exception &error,
|
||||
if (diagnosis && !diagnosis->possible_causes.empty())
|
||||
spec.possible_causes = diagnosis->possible_causes;
|
||||
|
||||
std::vector<ErrorEvidence> evidence;
|
||||
if (diagnosis && !diagnosis->evidence_edges.empty()) {
|
||||
// The failing edge(s) as orange lines on the solid; the same unmoved failure is drawn once (agent retry loops).
|
||||
DiagnosticImage image;
|
||||
image.kind = "render";
|
||||
image.operation = base.operation;
|
||||
image.view = "default";
|
||||
image.caption = diagnosis->evidence_caption;
|
||||
char size[32];
|
||||
std::snprintf(size, sizeof size, "%.1f", *attempt.size);
|
||||
image.dedup_key = base.operation + "|" + diagnosis->failure_kind + "|" + size;
|
||||
image.shapes = {solid};
|
||||
image.highlight_edges.assign(diagnosis->evidence_edges.begin(), diagnosis->evidence_edges.end());
|
||||
if (auto picture = diagnostic_image(image)) evidence.push_back(std::move(*picture));
|
||||
}
|
||||
|
||||
const std::string details =
|
||||
violation != nullptr
|
||||
? "BlendVolumeViolation: " + std::string(violation->what())
|
||||
@@ -60,7 +78,7 @@ raise_blend_failure(const ErrorSpec &base, const std::exception &error,
|
||||
raise_harness_error(
|
||||
spec, details,
|
||||
diagnosis ? diagnosis->measurements : std::vector<ErrorMeasurement>{},
|
||||
diagnosis ? diagnosis->repair : std::vector<std::string>{});
|
||||
diagnosis ? diagnosis->repair : std::vector<std::string>{}, {}, std::move(evidence));
|
||||
}
|
||||
|
||||
// The shared flow of fillet and chamfer once the size and the edges are known.
|
||||
|
||||
@@ -2,7 +2,9 @@
|
||||
|
||||
An operation that has diagnosed a failure asks for a picture (``DiagnosticImage`` in C++); this module draws it:
|
||||
|
||||
* ``render`` solids, each operand in its own colour, on the software renderer (four axonometric views);
|
||||
* ``render`` solids on the software renderer (four axonometric views): each operand in its own colour, or
|
||||
one solid with the implicated edges as orange lines (a failed blend); a failed QL selection
|
||||
is drawn by ``_ql_evidence``, which the QL layer asks for through its own hook;
|
||||
* ``wire_plan_render`` wires projected on their best-fit plane, the loose ends in orange (matplotlib);
|
||||
* ``sketch_render`` a sketch at the solver's positions, implicated entities orange, related ones purple (matplotlib).
|
||||
|
||||
@@ -60,7 +62,7 @@ def _evidence(kind: str, path: Path, view: str, caption: str, symbols: Sequence[
|
||||
|
||||
|
||||
def provide(kind: str, operation: str, view: str, caption: str, dedup_key: str, shapes: Sequence[Any],
|
||||
payload: Mapping[str, Any]) -> Optional[Dict[str, Any]]:
|
||||
payload: Mapping[str, Any], highlight_edges: Sequence[Any] = ()) -> Optional[Dict[str, Any]]:
|
||||
"""The provider the C++ side calls: the evidence dict for one requested picture, or None."""
|
||||
|
||||
if not enabled():
|
||||
@@ -71,7 +73,7 @@ def provide(kind: str, operation: str, view: str, caption: str, dedup_key: str,
|
||||
_RENDER_DEDUP.add(key)
|
||||
try:
|
||||
if kind == "render":
|
||||
return _render_solids(operation, view, caption, shapes, payload)
|
||||
return _render_solids(operation, view, caption, shapes, payload, highlight_edges)
|
||||
if kind == "wire_plan_render":
|
||||
return _wire_plan(operation, view, caption, shapes, payload)
|
||||
if kind == "sketch_render":
|
||||
@@ -86,10 +88,36 @@ def provide(kind: str, operation: str, view: str, caption: str, dedup_key: str,
|
||||
# ---- 3D: the operands on the software renderer ------------------------------------------------
|
||||
|
||||
|
||||
def _render_solids(operation: str, view: str, caption: str, shapes: Sequence[Any], payload: Mapping[str, Any]):
|
||||
from . import _native as _n
|
||||
def _draw_solids(operation: str, drawn: Sequence[Any], *, tags: Sequence[str] = (), tag_labels: Mapping[str, str] = {},
|
||||
edges: Sequence[Any] = (), callouts: bool = False) -> Path:
|
||||
from .screenshot import render_screenshot
|
||||
|
||||
path = _path(operation)
|
||||
render_screenshot(
|
||||
list(drawn),
|
||||
path,
|
||||
views=_DIAGNOSTIC_VIEWS,
|
||||
supersample=1,
|
||||
edge_width_scale=0.0035, # heavier model ink so panels read at grid size
|
||||
highlight_edge_width=8.0, # highlights outweigh the ink, always
|
||||
highlight_tags=tuple(tags),
|
||||
tag_labels=dict(tag_labels),
|
||||
highlight_edges=tuple(edges),
|
||||
show_legend=True,
|
||||
show_callouts=callouts,
|
||||
)
|
||||
return path
|
||||
|
||||
|
||||
def _render_solids(operation: str, view: str, caption: str, shapes: Sequence[Any], payload: Mapping[str, Any],
|
||||
highlight_edges: Sequence[Any] = ()):
|
||||
if highlight_edges:
|
||||
# One solid, the implicated edges as orange lines over it: nothing to tag.
|
||||
return _evidence("render", _draw_solids(operation, shapes, edges=list(highlight_edges)), view,
|
||||
caption)
|
||||
|
||||
from . import _native as _n
|
||||
|
||||
labels = list(payload.get("operand_labels") or [])
|
||||
tags: List[str] = []
|
||||
tag_labels: Dict[str, str] = {}
|
||||
@@ -101,20 +129,69 @@ def _render_solids(operation: str, view: str, caption: str, shapes: Sequence[Any
|
||||
drawn.append(copy)
|
||||
tags.append(tag)
|
||||
tag_labels[tag] = labels[index] if index < len(labels) else f"operand {index + 1}"
|
||||
path = _path(operation)
|
||||
render_screenshot(
|
||||
drawn,
|
||||
path,
|
||||
views=_DIAGNOSTIC_VIEWS,
|
||||
supersample=1,
|
||||
edge_width_scale=0.0035, # heavier model ink so panels read at grid size
|
||||
highlight_edge_width=8.0,
|
||||
highlight_tags=tuple(tags),
|
||||
tag_labels=tag_labels,
|
||||
show_legend=True,
|
||||
show_callouts=False, # a solid-tag anchor sits inside the solid and may point at the wrong body
|
||||
)
|
||||
return _evidence("render", path, view, caption)
|
||||
# A solid-tag callout anchor sits inside the solid and may point at the wrong body.
|
||||
return _evidence("render", _draw_solids(operation, drawn, tags=tags, tag_labels=tag_labels), view, caption)
|
||||
|
||||
|
||||
# ---- 3D: a QL selection that missed its cardinality -------------------------------------------
|
||||
|
||||
_MATCHED_TAG = "diagnostic.matched"
|
||||
_NEAR_MISS_TAG = "diagnostic.near_miss"
|
||||
|
||||
|
||||
def _ql_evidence(scope: Any, matched: Sequence[Any], target_kind: str, dedup_key: Any,
|
||||
near_misses: Sequence[Any]) -> List[Dict[str, Any]]:
|
||||
"""The provider the QL layer calls: the scope with the matched entities visibly highlighted.
|
||||
|
||||
A face selection draws a copy of the scope whose matched faces carry ``diagnostic.matched`` (orange) and up to
|
||||
three near-miss faces ``diagnostic.near_miss`` (purple), with legend and callouts; the user's own shape is never
|
||||
tagged. Other targets draw the first eight matched entities as orange lines.
|
||||
"""
|
||||
|
||||
if not enabled() or dedup_key in _RENDER_DEDUP:
|
||||
return []
|
||||
_RENDER_DEDUP.add(dedup_key)
|
||||
operation = f"ql_{target_kind}_resolve"
|
||||
try:
|
||||
from . import _native as _n
|
||||
|
||||
tags: List[str] = []
|
||||
tag_labels: Dict[str, str] = {}
|
||||
shapes: List[Any] = []
|
||||
if target_kind == "face" and scope.__class__.__name__ == "Solid":
|
||||
copy = _n.clone_semantic_view(scope)
|
||||
# Match by kernel topology identity: Python-level wrappers differ across copies, TopoDS identity does not.
|
||||
matched_wrapped = [item._native_wrapped for item in matched]
|
||||
near_wrapped = [item._native_wrapped for item in near_misses]
|
||||
matched_any = False
|
||||
near_tagged = 0
|
||||
for face in copy._iter_faces():
|
||||
if any(face._native_wrapped.IsSame(w) for w in matched_wrapped):
|
||||
face._apply_tag(_MATCHED_TAG, propagate=False)
|
||||
matched_any = True
|
||||
elif near_tagged < 3 and any(face._native_wrapped.IsSame(w) for w in near_wrapped):
|
||||
face._apply_tag(_NEAR_MISS_TAG, propagate=False)
|
||||
near_tagged += 1
|
||||
if matched_any:
|
||||
tags = [_MATCHED_TAG] + ([_NEAR_MISS_TAG] if near_tagged else [])
|
||||
tag_labels = {_MATCHED_TAG: f"matched {target_kind}(s)", _NEAR_MISS_TAG: "near miss"}
|
||||
shapes = [copy]
|
||||
edges: List[Any] = []
|
||||
if not shapes:
|
||||
# Everything but faces (and faces of a scope that is no solid, or none matched): the matched entities
|
||||
# themselves, as orange lines.
|
||||
edges = list(matched[:8])
|
||||
if scope.__class__.__name__ == "Solid":
|
||||
shapes = [scope]
|
||||
if not edges:
|
||||
return []
|
||||
path = _draw_solids(operation, shapes, tags=tags, tag_labels=tag_labels, edges=edges, callouts=bool(tags))
|
||||
except Exception as error: # noqa: BLE001 - a picture must never mask the error it illustrates
|
||||
return [_evidence("render-unavailable", Path(), "default",
|
||||
f"diagnostic render unavailable: {type(error).__name__}: {error}")]
|
||||
caption = ("orange = matched, purple = near miss; see inventory for identities" if target_kind == "face"
|
||||
else "orange lines = matched entities; see inventory")
|
||||
return [_evidence("render", path, "default", caption)]
|
||||
|
||||
|
||||
# ---- 2D: wires on their best-fit plane --------------------------------------------------------
|
||||
@@ -379,3 +456,4 @@ def install() -> None:
|
||||
from . import _native
|
||||
|
||||
_native._set_diagnostic_image_provider(provide)
|
||||
_native.ql._set_evidence_provider(_ql_evidence)
|
||||
|
||||
@@ -74,5 +74,9 @@
|
||||
"tests/test_topology_identity.py::test_shared_edge_occurrences_keep_entity_state_after_whole_assignment": [
|
||||
"internal",
|
||||
"tests the Python wrappers' internals (OperationNode dataclass/pickle, _TopoEntity, shape restore cost), which the C++ port does not have"
|
||||
],
|
||||
"test/test_error_diagnostics_blend_ql.py::test_ql_evidence_highlight_is_visible": [
|
||||
"open",
|
||||
"the picture is drawn and the matched cylinder bands are orange, but the soft renderer's shading leaves 302 sampled pixels within 40 of #f39c12 where the VTK picture of 2.2.6 had more than 400 (the test's threshold). A renderer-shading parity difference, not a missing picture"
|
||||
]
|
||||
}
|
||||
|
||||
@@ -0,0 +1,296 @@
|
||||
"""Fillet/chamfer degeneration taxonomy and QL selection-trust diagnosis.
|
||||
|
||||
One case per failure family from the accumulated degeneration catalog
|
||||
(repo history + OCC ecosystem): size vs face room, tangent adjacency,
|
||||
tangency-critical interaction, bore curvature, and the QL cardinality
|
||||
inventory with logical-surface grouping.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi.operators._diagnostics import _RENDER_DEDUP
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _no_render(monkeypatch):
|
||||
monkeypatch.setenv("SCA_NO_DIAGNOSTIC_RENDER", "1")
|
||||
|
||||
|
||||
def _box() -> scad.Solid:
|
||||
return scad.make_box_rsolid(10, 10, 10)
|
||||
|
||||
|
||||
def _box_edges(solid):
|
||||
return scad.ql.edges().resolve(solid)
|
||||
|
||||
|
||||
def _payload(error) -> dict:
|
||||
return error.to_dict()
|
||||
|
||||
|
||||
def test_chamfer_distance_exceeds_face_room():
|
||||
box = _box()
|
||||
edges = _box_edges(box)
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.chamfer_rsolid(box, [edges[0]], 12)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "distance 12 mm meets or exceeds the 10 mm" in payload["what_happened"]
|
||||
measurements = {m["name"]: m["value"] for m in payload["measurements"]}
|
||||
assert measurements["available_face_room"] == pytest.approx(10.0)
|
||||
assert any("below 10 mm" in step for step in payload["repair"])
|
||||
|
||||
|
||||
def test_fillet_radius_exceeds_face_room():
|
||||
box = _box()
|
||||
edges = _box_edges(box)
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(box, [edges[0]], 12)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "radius 12 mm meets or exceeds the 10 mm" in payload["what_happened"]
|
||||
measurements = {m["name"]: m["value"] for m in payload["measurements"]}
|
||||
assert measurements["radius"] == pytest.approx(12.0)
|
||||
|
||||
|
||||
def _slot_solid() -> scad.Solid:
|
||||
arc_left = scad.make_three_point_arc_redge((0, 5, 0), (-5, 0, 0), (0, -5, 0))
|
||||
line_bottom = scad.make_segment_redge((0, -5, 0), (20, -5, 0))
|
||||
arc_right = scad.make_three_point_arc_redge((20, -5, 0), (25, 0, 0), (20, 5, 0))
|
||||
line_top = scad.make_segment_redge((20, 5, 0), (0, 5, 0))
|
||||
wire = scad.make_wire_from_edges_rwire([arc_left, line_bottom, arc_right, line_top])
|
||||
return scad.extrude_rsolid(scad.make_face_from_wire_rface(wire), (0, 0, 1), 8)
|
||||
|
||||
|
||||
def test_fillet_tangent_adjacent_faces_degenerates():
|
||||
solid = _slot_solid()
|
||||
junction = None
|
||||
for edge in scad.ql.edges().resolve(solid):
|
||||
p1 = edge.get_start_vertex().get_coordinates()
|
||||
p2 = edge.get_end_vertex().get_coordinates()
|
||||
mid = tuple((a + b) / 2 for a, b in zip(p1, p2))
|
||||
if abs(mid[0]) < 1e-6 and abs(mid[1] - 5) < 1e-6:
|
||||
junction = edge
|
||||
break
|
||||
assert junction is not None
|
||||
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(solid, [junction], 1.0)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "already tangent" in payload["what_happened"]
|
||||
measurements = {m["name"]: m["value"] for m in payload["measurements"]}
|
||||
assert measurements["dihedral_angle"] == pytest.approx(180.0, abs=0.5)
|
||||
assert any("no corner to blend" in step for step in payload["repair"])
|
||||
|
||||
|
||||
def test_fillet_tangency_critical_all_edges():
|
||||
box = _box()
|
||||
edges = _box_edges(box)
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(box, edges, 5)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "meet tangentially" in payload["what_happened"]
|
||||
measurements = {m["name"]: m["value"] for m in payload["measurements"]}
|
||||
assert measurements["combined_blend_width"] == pytest.approx(10.0)
|
||||
assert measurements["available_face_room"] == pytest.approx(10.0)
|
||||
assert any("below 5 mm" in step for step in payload["repair"])
|
||||
|
||||
|
||||
def test_fillet_bore_mouth_boundary_room():
|
||||
# Tube: outer r=10 with a bore r=4 leaves a 6 mm annulus. Empirically
|
||||
# OCC accepts r=5 but fails at r=6 == annulus width: the boundary case
|
||||
# degenerates the top-face strip, and the room probe must say so.
|
||||
outer = scad.make_cylinder_rsolid(10, 10)
|
||||
bore = scad.make_cylinder_rsolid(4, 20, bottom_face_center=(0, 0, -5))
|
||||
tube = scad.cut_rsolid(outer, bore)
|
||||
mouth_edges = [
|
||||
edge
|
||||
for edge in scad.ql.edges().resolve(tube)
|
||||
if abs(edge.get_start_vertex().get_coordinates()[2]
|
||||
- edge.get_end_vertex().get_coordinates()[2]) < 1e-6
|
||||
and edge.get_start_vertex().get_coordinates()[2] > 9.0
|
||||
]
|
||||
assert mouth_edges
|
||||
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(tube, mouth_edges, 6)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "meets or exceeds" in payload["what_happened"]
|
||||
measurements = {m["name"]: m["value"] for m in payload["measurements"]}
|
||||
assert measurements["available_face_room"] == pytest.approx(6.0)
|
||||
assert any("below 6 mm" in step for step in payload["repair"])
|
||||
|
||||
|
||||
def test_fillet_silent_garbage_output_caught_at_exit():
|
||||
# Mechanism E: r=5 on all 12 edges of a 10-cube fails loudly, but r=6
|
||||
# makes the kernel *succeed* and hand back a degenerate solid. Geometrically
|
||||
# impossible; the exit check must name it instead of returning it.
|
||||
box = _box()
|
||||
edges = _box_edges(box)
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(box, edges, 6)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
what = payload["what_happened"]
|
||||
# The volume violation leads what_happened so the agent can tell
|
||||
# "kernel silently lied" apart from "kernel refused" (r=5 path). How the
|
||||
# garbage solid measures depends on the volume integrator: the fixed-order
|
||||
# one reported phantom extra material (~1036 on macOS, ~1039 on Linux, more
|
||||
# than the 1000 it was given); the knot-span (Gauss-Kronrod) one sees an
|
||||
# empty solid (volume 0). Either way the exit check must name it.
|
||||
garbage = re.search(r"result volume (?:is )?([0-9.]+)", what)
|
||||
assert garbage, what
|
||||
volume = float(garbage.group(1))
|
||||
if volume > 1000:
|
||||
assert "exceeds the input volume 1000" in what
|
||||
else:
|
||||
assert volume == 0.0
|
||||
assert "empty/degenerate solid" in what
|
||||
# Probe explanation follows as the suspected root cause.
|
||||
assert "probes indicate" in what
|
||||
assert "BlendVolumeViolation" in (payload["technical_details"] or "")
|
||||
|
||||
|
||||
def test_legit_fillet_passes_exit_check():
|
||||
# No false positives: an ordinary fillet must pass the monotonic-volume
|
||||
# guard untouched.
|
||||
box = _box()
|
||||
edges = _box_edges(box)
|
||||
result = scad.fillet_rsolid(box, [edges[0]], 1)
|
||||
assert len(result._iter_faces()) >= 6
|
||||
|
||||
|
||||
def test_concave_edge_fillet_may_add_material():
|
||||
# Regression: a bolt's underhead fillet rounds a concave (270°) edge,
|
||||
# and the corner fill legitimately ADDS material — observed as exactly
|
||||
# the quarter-circle deficit times the circumference (+1.28 mm³ on the
|
||||
# d=8 bolt). Mechanism E must skip the increase check for concave
|
||||
# selections, not call the kernel a liar.
|
||||
bolt = scad.std.fastener.make_bolt_rsolid(diameter=8.0, length=24.0)
|
||||
assert isinstance(bolt, scad.Solid)
|
||||
|
||||
|
||||
def _split_band_solid() -> scad.Solid:
|
||||
cylinder = scad.make_cylinder_rsolid(10, 20)
|
||||
ring = scad.make_cylinder_rsolid(12, 6, bottom_face_center=(0, 0, 7))
|
||||
inner = scad.make_cylinder_rsolid(9, 10, bottom_face_center=(0, 0, 5))
|
||||
return scad.cut_rsolid(cylinder, scad.cut_rsolid(ring, inner))
|
||||
|
||||
|
||||
def test_ql_ambiguity_reports_split_surface_group():
|
||||
part = _split_band_solid()
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.ql.faces().where(scad.ql.surface_type("CYLINDER")).exactly(1).resolve(part)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "expected exactly 1 face(s), got 3" in payload["what_happened"]
|
||||
assert "logical surface group" in payload["what_happened"]
|
||||
# The two r=10 bands are named as one logical group in the repair.
|
||||
assert any(
|
||||
"lie on one logical surface" in step and "F1+F6" in step
|
||||
for step in payload["repair"]
|
||||
)
|
||||
inventory = payload["inventory"]
|
||||
hits = [entry for entry in inventory if entry["status"] == "hit"]
|
||||
assert len(hits) == 3
|
||||
# Split pieces of one surface are distinguishable by their axial span.
|
||||
spans = [entry["description"] for entry in hits if "r=10" in entry["description"]]
|
||||
assert len(spans) == 2
|
||||
assert spans[0] != spans[1]
|
||||
assert any("z=[" in text for text in spans)
|
||||
# Near-misses describe what else exists (the planes).
|
||||
assert any("plane" in entry["description"] for entry in inventory)
|
||||
|
||||
|
||||
def test_ql_zero_hit_lists_near_miss_inventory():
|
||||
part = _split_band_solid()
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.ql.faces().where(scad.ql.surface_type("SPHERE")).at_least(1).resolve(part)
|
||||
|
||||
payload = _payload(ctx.value)
|
||||
assert "expected at least 1 face(s), got 0" in payload["what_happened"]
|
||||
inventory = payload["inventory"]
|
||||
assert all(entry["status"] == "near_miss" for entry in inventory)
|
||||
assert any("cylinder r=10" in entry["description"] for entry in inventory)
|
||||
assert any("align predicate values" in step for step in payload["repair"])
|
||||
|
||||
|
||||
def _count_palette_pixels(path: str, rgb: tuple, tolerance: int = 40) -> int:
|
||||
"""Sampled pixel count near a palette color — highlight visibility check."""
|
||||
|
||||
from PIL import Image
|
||||
|
||||
image = Image.open(path).convert("RGB")
|
||||
width, height = image.size
|
||||
return sum(
|
||||
1
|
||||
for x in range(0, width, 3)
|
||||
for y in range(0, height, 3)
|
||||
if all(
|
||||
abs(channel - target) <= tolerance
|
||||
for channel, target in zip(image.getpixel((x, y)), rgb)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def test_ql_evidence_highlight_is_visible(tmp_path, monkeypatch):
|
||||
monkeypatch.delenv("SCA_NO_DIAGNOSTIC_RENDER", raising=False)
|
||||
monkeypatch.chdir(tmp_path)
|
||||
_RENDER_DEDUP.clear()
|
||||
part = _split_band_solid()
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.ql.faces().where(scad.ql.surface_type("CYLINDER")).exactly(1).resolve(part)
|
||||
evidence = ctx.value.to_dict()["evidence"]
|
||||
assert len(evidence) == 1
|
||||
rendered = Path(evidence[0]["path"])
|
||||
assert rendered.exists()
|
||||
assert rendered.stat().st_size > 10_000
|
||||
assert evidence[0]["path"] in str(ctx.value)
|
||||
# The matched cylinder bands must be ORANGE in the image, not just
|
||||
# present in the scene: palette first color #f39c12.
|
||||
orange = _count_palette_pixels(str(rendered), (243, 156, 18))
|
||||
assert orange > 400, f"highlight not visible: only {orange} sampled orange pixels"
|
||||
|
||||
|
||||
def test_fillet_evidence_highlights_edge_as_line(tmp_path, monkeypatch):
|
||||
"""The failing edge renders as a crisp orange line, not marker geometry."""
|
||||
|
||||
monkeypatch.delenv("SCA_NO_DIAGNOSTIC_RENDER", raising=False)
|
||||
monkeypatch.chdir(tmp_path)
|
||||
_RENDER_DEDUP.clear()
|
||||
box = _box()
|
||||
with pytest.raises(scad.SimpleCADError) as ctx:
|
||||
scad.fillet_rsolid(box, [_box_edges(box)[0]], 12)
|
||||
evidence = ctx.value.to_dict()["evidence"]
|
||||
assert len(evidence) == 1
|
||||
orange = _count_palette_pixels(evidence[0]["path"], (243, 156, 18))
|
||||
assert orange > 40, f"edge line not visible: only {orange} sampled orange pixels"
|
||||
|
||||
|
||||
def _face_tags(face) -> set:
|
||||
try:
|
||||
return set(scad.list_tags(shape=face))
|
||||
except Exception:
|
||||
return set()
|
||||
|
||||
|
||||
def test_ql_highlight_does_not_pollute_user_shape(tmp_path, monkeypatch):
|
||||
monkeypatch.delenv("SCA_NO_DIAGNOSTIC_RENDER", raising=False)
|
||||
monkeypatch.chdir(tmp_path)
|
||||
_RENDER_DEDUP.clear()
|
||||
part = _split_band_solid()
|
||||
tags_before = {tag for face in part._iter_faces() for tag in _face_tags(face)}
|
||||
with pytest.raises(scad.SimpleCADError):
|
||||
scad.ql.faces().where(scad.ql.surface_type("CYLINDER")).exactly(1).resolve(part)
|
||||
tags_after = {tag for face in part._iter_faces() for tag in _face_tags(face)}
|
||||
assert tags_before == tags_after
|
||||
assert all("diagnostic" not in tag for tag in tags_after)
|
||||
Reference in New Issue
Block a user