slvs: support getting the bad constraints in the sketch solving API

This was only available in the system solving API until now, and that
made the sketch solving API less usable, even though it's the only API
available through the Cython and Emscripten bindings.

In this initial implementation there's a redundant allocation and copy
of the bad constraint list, but it was done this way in order to make
a minimal change that would be the most ergonomic to use from both the
C interface as well as the FFI binding interfaces.

Author: iscgar

exposed/CDemo.c

@@ -43,7 +43,7 @@ void ExampleStateful()
     // Slvs_Entity c1 = Slvs_AddCircle(g, n, center, radius, wp);
 
     Slvs_Vertical(g, p1, wp, p2);
-    Slvs_SolveResult res = Slvs_SolveSketch(g, 0);
+    Slvs_SolveResult res = Slvs_SolveSketch(g, NULL);
     printf("res: %i\n", res.result);
     printf("dof: %i\n", res.dof);
     double p1x = Slvs_GetParamValue(p1.param[0]);

include/slvs.h

@@ -207,7 +207,7 @@ typedef struct {
 typedef struct {
     int                 result;
     int                 dof;
-    int                 bad;
+    int                 nbad;
 } Slvs_SolveResult;
 
 /* Our base coordinate system has basis vectors
@@ -498,7 +498,14 @@ DLL double Slvs_GetParamValue(uint32_t ph);
 DLL void Slvs_SetParamValue(uint32_t ph, double value);
 
 DLL void Slvs_Solve(Slvs_System *sys, uint32_t hg);
-DLL Slvs_SolveResult Slvs_SolveSketch(uint32_t hg, int calculateFaileds);
+/**
+ * Setting `bad` to a non NULL pointer enables finding of bad constraints.
+ * If such constraints are found, `bad` is set to a heap allocated array containing
+ * the handles of those constraints, while the `nbad` member of the returned
+ * `Slvs_SolveResult` struct is set to the number of the bad constraints.
+ * NOTE: the user is responsible for freeing the heap allocated memory using `free()`.
+ */
+DLL Slvs_SolveResult Slvs_SolveSketch(uint32_t hg, Slvs_hConstraint **bad);
 DLL void Slvs_ClearSketch();
 
 #ifdef __cplusplus

js/slvs.d.ts

@@ -27,7 +27,8 @@ export interface Constraint {
 export interface SolveResult {
   result: number;
   dof: number;
-  bad: number;
+  nbad: number;
+  bad: Uint32Array;
 }
 
 export interface Vector {

src/slvs/jslib.cpp

@@ -2,6 +2,28 @@
 #include "slvs.h"
 #include <emscripten/bind.h>
 
+struct JsSolveResult {
+  int             result;
+  int             dof;
+  size_t          nbad;
+  emscripten::val bad;
+};
+
+static JsSolveResult solveSketch(Slvs_hGroup g, bool calculateFaileds) {
+  JsSolveResult jsResult = {};
+  Slvs_hConstraint *c = nullptr;
+  Slvs_SolveResult ret = Slvs_SolveSketch(g, calculateFaileds ? &c : nullptr);
+  if(c) {
+    jsResult.bad = emscripten::val::global("Uint32Array").new_(ret.nbad);
+    jsResult.bad.call<void>("set", emscripten::typed_memory_view(ret.nbad, c));
+    free(c);
+  }
+  jsResult.result = ret.result;
+  jsResult.dof = ret.dof;
+  jsResult.nbad = ret.nbad;
+  return jsResult;
+}
+
 EMSCRIPTEN_BINDINGS(slvs) {
   emscripten::constant("C_POINTS_COINCIDENT",   SLVS_C_POINTS_COINCIDENT);
   emscripten::constant("C_PT_PT_DISTANCE",      SLVS_C_PT_PT_DISTANCE);
@@ -93,10 +115,11 @@ EMSCRIPTEN_BINDINGS(slvs) {
     .field("other", &Slvs_Constraint::other)
     .field("other2", &Slvs_Constraint::other2);
 
-  emscripten::value_object<Slvs_SolveResult>("Slvs_SolveResult")
-    .field("result", &Slvs_SolveResult::result)
-    .field("dof", &Slvs_SolveResult::dof)
-    .field("bad", &Slvs_SolveResult::bad);
+  emscripten::value_object<JsSolveResult>("Slvs_SolveResult")
+    .field("result", &JsSolveResult::result)
+    .field("dof", &JsSolveResult::dof)
+    .field("nbad", &JsSolveResult::nbad)
+    .field("bad", &JsSolveResult::bad);
 
   emscripten::class_<Quaternion>("Quaternion")
     .constructor<>()
@@ -178,6 +201,6 @@ EMSCRIPTEN_BINDINGS(slvs) {
 
   emscripten::function("getParamValue", &Slvs_GetParamValue);
   emscripten::function("setParamValue", &Slvs_SetParamValue);
-  emscripten::function("solveSketch", &Slvs_SolveSketch);
+  emscripten::function("solveSketch", &solveSketch);
   emscripten::function("clearSketch", &Slvs_ClearSketch);
 }

src/slvs/lib.cpp

@@ -835,7 +835,7 @@ void Slvs_ClearSketch()
     SK.constraint.Clear();
 }
 
-Slvs_SolveResult Slvs_SolveSketch(uint32_t shg, int calculateFaileds = 0)
+Slvs_SolveResult Slvs_SolveSketch(uint32_t shg, Slvs_hConstraint **bad = nullptr)
 {
     SYS.Clear();
 
@@ -916,13 +916,23 @@ Slvs_SolveResult Slvs_SolveSketch(uint32_t shg, int calculateFaileds = 0)
     // }
 
     List<hConstraint> badList;
-    bool andFindBad = calculateFaileds ? true : false;
+    bool andFindBad = bad != nullptr;
 
     int dof = 0;
     SolveResult status = SYS.Solve(&g, &dof, &badList, andFindBad, false, false);
     Slvs_SolveResult sr = {};
     sr.dof = dof;
-    sr.bad = badList.n;
+    sr.nbad = badList.n;
+    if(bad) {
+        if(sr.nbad <= 0) {
+            *bad = nullptr;
+        } else {
+            *bad = static_cast<Slvs_hConstraint *>(malloc(sizeof(Slvs_hConstraint) * sr.nbad));
+            for(int i = 0; i < sr.nbad; ++i) {
+                (*bad)[i] = badList[i].v;
+            }
+        }
+    }
     sr.result = 0;
     switch(status) {
         case SolveResult::OKAY: {

src/slvs/lib.pyx

@@ -1,11 +1,13 @@
 #cython: language_level=3
 from enum import IntEnum, auto
+from libc.stdint cimport uint32_t
+from libc.stdlib cimport free
 
 cdef extern from "slvs.h" nogil:
-    ctypedef int Slvs_hEntity
-    ctypedef int Slvs_hGroup
-    ctypedef int Slvs_hConstraint
-    ctypedef int Slvs_hParam
+    ctypedef uint32_t Slvs_hEntity
+    ctypedef uint32_t Slvs_hGroup
+    ctypedef uint32_t Slvs_hConstraint
+    ctypedef uint32_t Slvs_hParam
 
     ctypedef struct Slvs_Entity:
         Slvs_hEntity h
@@ -35,7 +37,7 @@ cdef extern from "slvs.h" nogil:
     ctypedef struct Slvs_SolveResult:
         int result
         int dof
-        int bad
+        int nbad
 
     void Slvs_QuaternionU(double qw, double qx, double qy, double qz,
                              double *x, double *y, double *z)
@@ -84,7 +86,7 @@ cdef extern from "slvs.h" nogil:
     Slvs_Constraint Slvs_LengthDiff(Slvs_hGroup grouph, Slvs_Entity entityA, Slvs_Entity entityB, double value, Slvs_Entity workplane)
     Slvs_Constraint Slvs_Dragged(Slvs_hGroup grouph, Slvs_Entity ptA, Slvs_Entity workplane)
 
-    Slvs_SolveResult Slvs_SolveSketch(Slvs_hGroup hg, int calculateFaileds) nogil
+    Slvs_SolveResult Slvs_SolveSketch(Slvs_hGroup hg, Slvs_hConstraint **bad) nogil
     double Slvs_GetParamValue(int ph)
     double Slvs_SetParamValue(int ph, double value)
     void Slvs_ClearSketch()
@@ -363,7 +365,17 @@ class EntityType(IntEnum):
     ARC_OF_CIRCLE = _SLVS_E_ARC_OF_CIRCLE
 
 def solve_sketch(grouph: int, calculateFaileds: bool):
-    return Slvs_SolveSketch(grouph, calculateFaileds)
+    cdef Slvs_hConstraint *badp = NULL
+    if not calculateFaileds:
+        return Slvs_SolveSketch(grouph, NULL)
+    else:
+        result = Slvs_SolveSketch(grouph, &badp)
+        bad = []
+        if badp != NULL:
+            for i in range(0, result.nbad):
+                bad.append(badp[i])
+            free(badp)
+        return result, bad
 
 def get_param_value(ph: int):
     return Slvs_GetParamValue(ph)