brep_kernel/abi/
geometry.rs

1use super::*;
2
3#[derive(Deserialize)]
4pub(crate) struct CurveEvaluationRequest {
5    pub(crate) curve: NurbsCurve,
6    pub(crate) parameters: Vec<f64>,
7}
8
9#[derive(Deserialize)]
10pub(crate) struct CurveDerivativeRequest {
11    pub(crate) curve: NurbsCurve,
12    pub(crate) parameter: f64,
13    pub(crate) derivative_count: usize,
14}
15
16#[derive(Deserialize)]
17pub(crate) struct CurveProjectionRequest {
18    pub(crate) curve: NurbsCurve,
19    pub(crate) point: Vec3,
20}
21
22#[derive(Deserialize)]
23pub(crate) struct SurfaceProjectionRequest {
24    pub(crate) surface: NurbsSurface,
25    pub(crate) point: Vec3,
26}
27
28#[derive(Deserialize)]
29pub(crate) struct CurveSurfaceIntersectionRequest {
30    pub(crate) curve: NurbsCurve,
31    pub(crate) surface: NurbsSurface,
32    #[serde(default = "default_intersection_tolerance")]
33    pub(crate) tolerance: f64,
34}
35
36#[derive(Deserialize)]
37pub(crate) struct CurveCurveIntersectionRequest {
38    pub(crate) first: NurbsCurve,
39    pub(crate) second: NurbsCurve,
40    #[serde(default = "default_intersection_tolerance")]
41    pub(crate) tolerance: f64,
42}
43
44#[derive(Deserialize)]
45pub(crate) struct SurfaceSurfaceIntersectionRequest {
46    pub(crate) first: NurbsSurface,
47    pub(crate) second: NurbsSurface,
48    #[serde(default)]
49    pub(crate) options: SurfaceIntersectionOptions,
50}
51
52pub(crate) fn default_intersection_tolerance() -> f64 {
53    1e-7
54}
55
56#[derive(Deserialize)]
57pub(crate) struct LineRequest {
58    pub(crate) start: Vec3,
59    pub(crate) end: Vec3,
60}
61
62#[derive(Deserialize)]
63pub(crate) struct ArcRequest {
64    pub(crate) center: Vec3,
65    pub(crate) x_axis: Vec3,
66    pub(crate) y_axis: Vec3,
67    pub(crate) radius: f64,
68    pub(crate) start_angle: f64,
69    pub(crate) end_angle: f64,
70}
71
72#[derive(Deserialize)]
73pub(crate) struct CircleRequest {
74    pub(crate) center: Vec3,
75    pub(crate) normal: Vec3,
76    pub(crate) radius: f64,
77}
78
79#[derive(Deserialize)]
80pub(crate) struct ParabolaRequest {
81    pub(crate) vertex: Vec3,
82    pub(crate) axis: Vec3,
83    pub(crate) latus_direction: Vec3,
84    pub(crate) focal: f64,
85    pub(crate) t0: f64,
86    pub(crate) t1: f64,
87}
88
89#[derive(Deserialize)]
90pub(crate) struct HyperbolaRequest {
91    pub(crate) center: Vec3,
92    pub(crate) major_axis: Vec3,
93    pub(crate) minor_axis: Vec3,
94    pub(crate) a: f64,
95    pub(crate) b: f64,
96    pub(crate) t0: f64,
97    pub(crate) t1: f64,
98}
99
100#[derive(Deserialize)]
101pub(crate) struct BandedSolveRequest {
102    pub(crate) matrix: Vec<Vec<f64>>,
103    pub(crate) rhs: Vec<f64>,
104    pub(crate) bandwidth: usize,
105}
106
107#[derive(Deserialize)]
108pub(crate) struct DenseSolveRequest {
109    pub(crate) matrix: Vec<Vec<f64>>,
110    pub(crate) rhs: Vec<f64>,
111}
112
113#[derive(Deserialize)]
114pub(crate) struct SegmentIntersectionRequest {
115    pub(crate) a1: Vec2,
116    pub(crate) b1: Vec2,
117    pub(crate) a2: Vec2,
118    pub(crate) b2: Vec2,
119    pub(crate) tolerance: f64,
120}
121
122#[derive(Deserialize)]
123pub(crate) struct PointInPolygonRequest {
124    pub(crate) point: Vec2,
125    pub(crate) polygon: Vec<Vec2>,
126    pub(crate) tolerance: f64,
127}
128
129#[derive(Deserialize)]
130pub(crate) struct ParameterPointInFaceRequest {
131    pub(crate) face: FaceRecord,
132    pub(crate) point: Vec2,
133    pub(crate) tolerance: f64,
134}
135
136#[derive(Deserialize)]
137pub(crate) struct ThinnedCurveRequest {
138    pub(crate) points: Vec<Vec3>,
139    #[serde(default = "default_curve_fit_degree")]
140    pub(crate) degree: usize,
141    #[serde(default = "default_curve_fit_maximum_points")]
142    pub(crate) maximum_points: usize,
143}
144
145pub(crate) fn default_curve_fit_degree() -> usize {
146    3
147}
148
149pub(crate) fn default_curve_fit_maximum_points() -> usize {
150    200
151}
152
153/// A typed refusal crossing the wasm ABI: the flattened refusal object
154/// (`{"class":…,…,"stage":…,"message":…}`) as the error's text, so a JS
155/// consumer can dispatch on the class and still show the message.
156pub(crate) fn javascript_refusal(refusal: crate::KernelRefusal) -> JsValue {
157    let text = serde_json::to_string(&refusal).unwrap_or_else(|_| refusal.message.clone());
158    javascript_error(text)
159}
160
161pub(crate) fn javascript_error(error: String) -> JsValue {
162    JsValue::from_str(&error)
163}
164
165/// Parse a JSON request crossing the wasm ABI; a malformed request is the
166/// serde error's text as the JavaScript error.
167pub(crate) fn json_in<'a, T: serde::Deserialize<'a>>(request_json: &'a str) -> Result<T, JsValue> {
168    serde_json::from_str(request_json).map_err(|error| javascript_error(error.to_string()))
169}
170
171/// Serialize a reply crossing the wasm ABI; a serialization failure is the
172/// serde error's text as the JavaScript error.
173pub(crate) fn json_out<T: ?Sized + serde::Serialize>(value: &T) -> Result<String, JsValue> {
174    serde_json::to_string(value).map_err(|error| javascript_error(error.to_string()))
175}
176
177#[wasm_bindgen]
178pub fn curve_evaluate_json(request_json: &str) -> Result<String, JsValue> {
179    let request: CurveEvaluationRequest = json_in(request_json)?;
180    let curve = NurbsCurve::new(
181        request.curve.degree,
182        request.curve.knots,
183        request.curve.control_points,
184    )
185    .map_err(javascript_error)?;
186    let points: Result<Vec<Vec3>, String> = request
187        .parameters
188        .into_iter()
189        .map(|parameter| curve.evaluate(parameter))
190        .collect();
191    json_out(&points.map_err(javascript_error)?)
192}
193
194#[wasm_bindgen]
195pub fn project_curve_json(request_json: &str) -> Result<String, JsValue> {
196    let request: CurveProjectionRequest = json_in(request_json)?;
197    let projection =
198        project_point_to_curve(&request.curve, request.point).map_err(javascript_error)?;
199    json_out(&projection)
200}
201
202#[wasm_bindgen]
203pub fn project_surface_json(request_json: &str) -> Result<String, JsValue> {
204    let request: SurfaceProjectionRequest = json_in(request_json)?;
205    let projection =
206        project_point_to_surface(&request.surface, request.point).map_err(javascript_error)?;
207    json_out(&projection)
208}
209
210#[wasm_bindgen]
211pub fn intersect_curve_surface_json(request_json: &str) -> Result<String, JsValue> {
212    let request: CurveSurfaceIntersectionRequest = json_in(request_json)?;
213    let intersections =
214        intersect_curve_surface(&request.curve, &request.surface, request.tolerance)
215            .map_err(javascript_error)?;
216    json_out(&intersections)
217}
218
219#[wasm_bindgen]
220pub fn intersect_curves_json(request_json: &str) -> Result<String, JsValue> {
221    let request: CurveCurveIntersectionRequest = json_in(request_json)?;
222    let intersections = intersect_curves(&request.first, &request.second, request.tolerance)
223        .map_err(javascript_error)?;
224    json_out(&intersections)
225}
226
227#[wasm_bindgen]
228pub fn intersect_surfaces_json(request_json: &str) -> Result<String, JsValue> {
229    let request: SurfaceSurfaceIntersectionRequest = json_in(request_json)?;
230    let intersections = intersect_surfaces(&request.first, &request.second, &request.options)
231        .map_err(javascript_error)?;
232    json_out(&intersections)
233}
234
235#[wasm_bindgen]
236pub fn curve_derivatives_json(request_json: &str) -> Result<String, JsValue> {
237    let request: CurveDerivativeRequest = json_in(request_json)?;
238    let curve = NurbsCurve::new(
239        request.curve.degree,
240        request.curve.knots,
241        request.curve.control_points,
242    )
243    .map_err(javascript_error)?;
244    json_out(
245        &curve
246            .derivatives(request.parameter, request.derivative_count)
247            .map_err(javascript_error)?,
248    )
249}
brep_kernel/abi/geometry.rs

brep_kernel/abi/
geometry.rs
