DAVID4 SDK  1.8.7
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
JsonRpcFunctions.h
1 //=============================================================================
2 // See License in Related Pages
3 //=============================================================================
4 
5 #pragma once
6 
7 #ifndef DAVID_SDK_JSON_RPC_FUNCTIONS_H
8 #define DAVID_SDK_JSON_RPC_FUNCTIONS_H
9 
10 namespace david {
11 
12 //*****************************************************************************
13 /// @addtogroup LowLevelGroup
14 /// @{
15 /// @defgroup JsonRpcGroup JsonRPC protocol specification
16 /// Specification of communication protocol between a DAVID client and a DAVID Enterprise Server
17 /// using JsonRPC remote procedure calls.
18 /// @{
19 //*****************************************************************************
20 
21 /// Specifications for DAVID remote procedure calls in JSON RPC 2.0.
22 ///
23 /// @warning Only for advanced users who want to implement the protocol for a different platform.
24 ///
25 /// A list of supported JSON RPC 2.0 functions in DAVID is given in the documentation of the following enumerators:
26 /// - david::jsonrpc::JsonRpcFunctions
27 /// - david::jsonrpc::JsonRpcFunctions_sls
28 /// - david::jsonrpc::JsonRpcFunctions_turntable
29 /// - david::jsonrpc::JsonRpcFunctions_shapefusion
30 /// - david::jsonrpc::JsonRpcFunctions_measure
31 ///
32 /// Only "params" and "result" of the transmitted JSON RPC 2.0 content is documented in the enumerators. Complete example:
33 ///
34 /// @code
35 /// --> {"jsonrpc": "2.0", "method": "david::shapefusion::DeleteMesh", "params": {"meshID" : 5}, "id": 1}
36 /// <-- {"jsonrpc": "2.0", "result": null, "id": 1}
37 /// @endcode
38 ///
39 /// Or in case of an error:
40 ///
41 /// @code
42 /// --> {"jsonrpc": "2.0", "method": "david::shapefusion::DeleteMesh", "params": {"meshID" : 5}, "id": 1}
43 /// <-- {"jsonrpc": "2.0", "error": {"code" : -1, "message" : "Invalid mesh ID."}, "id": 1}
44 /// @endcode
45 ///
46 /// @note In the individual <b>Error Codes</b> sections of the following documentation
47 /// the possible error codes are defined. In case of an error this error is returned
48 /// in "code" of "error" (see example above).
49 ///
50 /// @see http://www.jsonrpc.org/specification
51 ///
52 namespace jsonrpc {
53 
54 
55 /// A list of supported JSON RPC 2.0 functions in namespace david.
56 ///
58 {
59  /// Initializes connection between client and server.
60  ///
61  /// @code
62  /// "method": "david::Connect"
63  ///
64  /// --> "params" : {"clientVersion" : double}
65  /// <-- "result" : {"serverVersion" : string, "licenseOk" : bool}
66  /// <-- "error" : {"code" : int, "message" : string}
67  /// @endcode
68  ///
69  /// <b>Parameters</b>
70  /// <table borders="0">
71  /// <tr> <td>clientVersion</td> <td>Version of the client software represented as a double (like 1.1).</td> </tr>
72  /// </table>
73  ///
74  /// <b>Return Values</b>
75  /// <table borders="0">
76  /// <tr> <td>serverVersion</td> <td>Version of the server software.</td> </tr>
77  /// <tr> <td>licenseOk</td> <td>Is license of server ok?</td> </tr>
78  /// </table>
79  ///
80  /// <b>Error Codes</b>
81  /// <table borders="0">
82  /// <tr> <td>david::Error_RpcClientVersion</td> <td>Client version not compatible.</td> </tr>
83  /// </table>
84  ///
86 
87  /// Informs the server that the client is going to disconnect.
88  ///
89  /// @code
90  /// "method": "david::Disconnect"
91  ///
92  /// --> "params" : null
93  /// <-- "result" : null
94  /// <-- "error" : {"code" : int, "message" : string}
95  /// @endcode
96  ///
98 
99  /// Requests IP address and port for setting up a binary channel over TCP/IP.
100  ///
101  /// @code
102  /// "method": "david::RequestBinaryChannel"
103  ///
104  /// --> "params" : null
105  /// <-- "result" : {"port" : uint16_t}
106  /// <-- "error" : {"code" : int, "message" : string}
107  /// @endcode
108  ///
109  /// <b>Return Values</b>
110  /// <table borders="0">
111  /// <tr> <td>port</td> <td>Server port for the connection of the binary channel.</td> </tr>
112  /// </table>
113  ///
114  /// <b>Error Codes</b>
115  /// <table borders="0">
116  /// <tr> <td>david::Error_BinarySetup</td> <td>Binary channel not supported.</td> </tr>
117  /// </table>
118  ///
120 
121  /// Shows the main window of DAVID Server.
122  ///
123  /// @code
124  /// "method": "david::ShowMainWindow"
125  ///
126  /// --> "params" : null
127  /// <-- "result" : null
128  /// <-- "error" : {"code" : int, "message" : string}
129  /// @endcode
130  ///
132 
133  /// Hides the main window of DAVID Server.
134  ///
135  /// @code
136  /// "method": "david::HideMainWindow"
137  ///
138  /// --> "params" : null
139  /// <-- "result" : null
140  /// <-- "error" : {"code" : int, "message" : string}
141  /// @endcode
142  ///
144 
145  /// Shows the GUI menus in DAVID Server.
146  ///
147  /// @code
148  /// "method": "david::ShowMenus"
149  ///
150  /// --> "params" : null
151  /// <-- "result" : null
152  /// <-- "error" : {"code" : int, "message" : string}
153  /// @endcode
154  ///
156 
157  /// Hides the GUI menus in DAVID Server.
158  ///
159  /// @code
160  /// "method": "david::HideMenus"
161  ///
162  /// --> "params" : null
163  /// <-- "result" : null
164  /// <-- "error" : {"code" : int, "message" : string}
165  /// @endcode
166  ///
168 
169  /// Stops the DAVID SDK Server.
170  ///
171  /// @code
172  /// "method": "david::StopServer"
173  ///
174  /// --> "params" : null
175  /// <-- "result" : null
176  /// <-- "error" : {"code" : int, "message" : string}
177  /// @endcode
178  ///
180 };
181 
182 
183 /// A list of supported JSON RPC 2.0 functions in namespace david::sls.
184 ///
186 {
187  /// Sets the new screen ID.
188  ///
189  /// @code
190  /// "method": "david::sls::SetScreenID"
191  ///
192  /// --> "params" : {"screenID" : int}
193  /// <-- "result" : null
194  /// <-- "error" : {"code" : int, "message" : string}
195  /// @endcode
196  ///
197  /// <b>Parameters</b>
198  /// <table borders="0">
199  /// <tr> <td>screenID</td> <td>ID of the screen used for displaying structured light patterns, or 0 for OFF.</td> </tr>
200  /// </table>
201  ///
202  /// <b>Error Codes</b>
203  /// <table borders="0">
204  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid screen ID.</td> </tr>
205  /// </table>
206  ///
208 
209  /// Gets a list of available cameras.
210  ///
211  /// @code
212  /// "method": "david::sls::GetAvailableCameraNames"
213  ///
214  /// --> "params" : null
215  /// <-- "result" : {"names" : string[]}
216  /// <-- "error" : {"code" : int, "message" : string}
217  /// @endcode
218  ///
219  /// <b>Return Values</b>
220  /// <table borders="0">
221  /// <tr> <td>names</td> <td>Array of strings, containing the names of the cameras.</td> </tr>
222  /// </table>
223  ///
225 
226  /// Selects a new camera.
227  /// Note: For using pre-recorded image files, please see david::sls::SelectImageSequence.
228  ///
229  /// @code
230  /// "method": "david::sls::SelectCamera"
231  ///
232  /// --> "params" : {"cameraName" : string, "format" : {"width" : uint32_t, "height" : uint32_t, "fps" : double, "pixelFormat" : string}}
233  /// <-- "result" : null
234  /// <-- "error" : {"code" : int, "message" : string}
235  /// @endcode
236  ///
237  /// <b>Parameters</b>
238  /// <table borders="0">
239  /// <tr> <td>cameraName</td> <td></td> <td></td> <td>Name of the camera.</td> </tr>
240  /// <tr> <td>[imageFormat]</td> <td></td> <td></td> <td>Desired camera format [optional].</td> </tr>
241  /// <tr> <td></td> <td>width</td> <td></td> <td>Desired width. Set 0 for default.</td> </tr>
242  /// <tr> <td></td> <td>height</td> <td></td> <td>Desired height. Set 0 for default.</td> </tr>
243  /// <tr> <td></td> <td>fps</td> <td></td> <td>Desired frames per second. Set 0 for default.</td> </tr>
244  /// <tr> <td></td> <td>pixelFormat</td> <td></td> <td>Pixel format type:</td> </tr>
245  /// <tr> <td></td> <td></td> <td>Default</td> <td>Use default pixel format.</td> </tr>
246  /// <tr> <td></td> <td></td> <td>Y800</td> <td>Standard 8bit grayscale format.</td> </tr>
247  /// <tr> <td></td> <td></td> <td>BY8</td> <td>Standard 8bit Bayer format.</td> </tr>
248  /// <tr> <td></td> <td></td> <td>RGB24</td> <td>Red, green, and blue 8bit color components for each pixel.</td> </tr>
249  /// <tr> <td></td> <td></td> <td>YUY2</td> <td>16bit color format. Byte 0=8-bit Y'0; Byte 1=8-bit Cb; Byte 2=8-bit Y'1; Byte 3=8-bit Cr.</td> </tr>
250  /// </table>
251  ///
252  /// <b>Error Codes</b>
253  /// <table borders="0">
254  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Selected camera is not available.</td> </tr>
255  /// <tr> <td>david::Error_FormatNotAvailable</td> <td>Selected camera image format is invalid.</td> </tr>
256  /// </table>
257  ///
259 
260  /// Checks the state of the camera.
261  ///
262  /// @code
263  /// "method": "david::sls::CheckCamera"
264  ///
265  /// --> "params" : null
266  /// <-- "result" : bool
267  /// <-- "error" : {"code" : int, "message" : string}
268  /// @endcode
269  ///
270  /// <b>Return Values</b>
271  /// <table borders="0">
272  /// <tr> <td>true</td> <td>Camera is connected and is working correctly.</td> </tr>
273  /// <tr> <td>false</td> <td>Camera is not working correctly or camera is not connected.</td> </tr>
274  /// </table>
275  ///
277 
278  /// Sets the camera property 'propertyName'.
279  ///
280  /// @code
281  /// "method": "david::sls::SetCameraProperty"
282  ///
283  /// --> "params" : {"propertyName" : string, "value" : double, "usage" : string}
284  /// <-- "result" : null
285  /// <-- "error" : {"code" : int, "message" : string}
286  /// @endcode
287  ///
288  /// <b>Parameters</b>
289  /// <table borders="0">
290  /// <tr> <td>propertyName</td> <td>Name of camera property.</td> </tr>
291  /// <tr> <td>value</td> <td>New value of the property.</td> </tr>
292  /// <tr> <td>[usage]</td> <td>Usage for camera property. If usage is omitted, property value is set for all cases.</td> </tr>
293  /// <tr> <td></td> <td>Scanning</td> <td>Property should be used for scanning only.</td> </tr>
294  /// <tr> <td></td> <td>Texturing</td> <td>Property should be used for texturing only.</td> </tr>
295  /// </table>
296  ///
297  /// <b>Error Codes</b>
298  /// <table borders="0">
299  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Selected camera is not available.</td> </tr>
300  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid property or property is not available.</td> </tr>
301  /// </table>
302  ///
304 
305  /// Gets the camera property 'propertyName'.
306  ///
307  /// @code
308  /// "method": "david::sls::GetCameraProperty"
309  ///
310  /// --> "params" : {"propertyName" : string, "usage" : string}
311  /// <-- "result" : {"value" : double}
312  /// <-- "error" : {"code" : int, "message" : string}
313  /// @endcode
314  ///
315  /// <b>Parameters</b>
316  /// <table borders="0">
317  /// <tr> <td>propertyName</td> <td>Name of camera property.</td> </tr>
318  /// <tr> <td>usage</td> <td>Usage for camera property. If usage is omitted, property value is set for all cases.</td> </tr>
319  /// <tr> <td></td> <td>Scanning</td> <td>Property should be used for scanning only.</td> </tr>
320  /// <tr> <td></td> <td>Texturing</td> <td>Property should be used for texturing only.</td> </tr>
321  /// </table>
322  ///
323  /// <b>Error Codes</b>
324  /// <table borders="0">
325  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Selected camera is not available.</td> </tr>
326  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid property or property is not available.</td> </tr>
327  /// </table>
328  ///
329  /// <b>Return Values</b>
330  /// <table borders="0">
331  /// <tr> <td>value</td> <td>Value of the property.</td> </tr>
332  /// </table>
333  ///
335 
336  /// Gets a list of camera property names. This list may depend on the used camera.
337  ///
338  /// @code
339  /// "method": "david::sls::GetCameraPropertyNames"
340  ///
341  /// --> "params" : {"onlyAvailable" : bool}
342  /// <-- "result" : {"names" : string[]}
343  /// <-- "error" : {"code" : int, "message" : string}
344  /// @endcode
345  ///
346  /// <b>Return Values</b>
347  /// <table borders="0">
348  /// <tr> <td>names</td> <td>Array of strings, containing the names of camera properties.</td> </tr>
349  /// </table>
350  ///
352 
353  /// Selects a sequence of image files as "virtual camera". All images must be located in the same directory.
354  /// The image file names are chosen automatically:
355  /// <table borders="0">
356  /// <tr> <td>Image for camera calibration</td> <td>File name must contain "cam_calib"</td> </tr>
357  /// <tr> <td>Pattern images</td> <td>File names must contain "image" and be sorted alphabetically.</td> </tr>
358  /// <tr> <td>Texture image</td> <td>File name must contain "texture"</td> </tr>
359  /// </table>
360  ///
361  /// @code
362  /// "method": "david::sls::SelectImageSequence"
363  ///
364  /// --> "params" : {"directory" : string}
365  /// <-- "result" : null
366  /// <-- "error" : {"code" : int, "message" : string}
367  /// @endcode
368  ///
369  /// <b>Parameters</b>
370  /// <table borders="0">
371  /// <tr> <td>directory</td> <td>Path to the image files.</td> </tr>
372  /// </table>
373  ///
374  /// <b>Error Codes</b>
375  /// <table borders="0">
376  /// <tr> <td>david::Error_InvalidPath</td> <td>Path invalid.</td> </tr>
377  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Directory does not exist.</td> </tr>
378  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Could not read image sequence.</td> </tr>
379  /// </table>
380  ///
382 
383  /// Gets the current grayscale live image from the camera.
384  ///
385  /// @code
386  /// "method": "david::sls::GetLiveImage"
387  ///
388  /// --> "params" : null
389  /// <-- "result" : {"width" : int, "height" : int, "size" : uint32_t}
390  /// <-- "error" : {"code" : int, "message" : string}
391  /// @endcode
392  ///
393  /// <b>Return Values</b>
394  /// <table borders="0">
395  /// <tr> <td>width</td> <td>Width of the camera image.</td> </tr>
396  /// <tr> <td>height</td> <td>Height of the camera image.</td> </tr>
397  /// <tr> <td>size</td> <td>Size of the pixel buffer in bytes to be transmitted over binary channel.</td> </tr>
398  /// </table>
399  ///
400  /// <b>Error Codes</b>
401  /// <table borders="0">
402  /// <tr> <td>david::Error_NoLiveImage</td> <td>Live image is not available.</td> </tr>
403  /// </table>
404  ///
406 
407  /// Selects scan mode Coded Light + Phase Shift (standard DAVID4 mode) and sets the parameters.
408  /// Missing parameters will remain unchanged.
409  ///
410  /// @code
411  /// "method": "david::sls::SetCodedLightPhaseShiftMode"
412  ///
413  /// --> "params" : {"inverse" : bool, "shifts" : int, "orientation" : string, "brightness" : int, "noiseReduction" : int}
414  /// <-- "result" : null
415  /// <-- "error" : {"code" : int, "message" : string}
416  /// @endcode
417  ///
418  /// <b>Parameters</b>
419  /// <table borders="0">
420  /// <tr> <td>[frequencies]</td> <td>Number of pattern frequencies. Default is 0 == auto.</td> </tr>
421  /// <tr> <td>[inverse]</td> <td>Use inverse Coded Light patterns [true|false]. Doubles the amount of Coded Light patterns.</td> </tr>
422  /// <tr> <td>[shifts]</td> <td>Number of sine patterns (Phase Shift shifts) [3-16].</td> </tr>
423  /// <tr> <td>[orientation]</td> <td></td> <td>Orientation of SL patterns</td> </tr>
424  /// <tr> <td></td> <td>horizontal</td> <td>Patterns for horizontal setups only (projector and camera are next to each other).</td> </tr>
425  /// <tr> <td></td> <td>vertical</td> <td>Patterns for vertical setups only (projector and camera are above each other).</td> </tr>
426  /// <tr> <td></td> <td>both</td> <td>Both pattern orientations (projector and camera are located diagonally).</td> </tr>
427  /// <tr> <td>[brightness]</td> <td>Brightness of the projected patterns [0-255]. Default is [255].</td> </tr>
428  /// <tr> <td>[color]</td> <td></td> <td>Color of SL patterns. Default is white.</td> </tr>
429  /// <tr> <td></td> <td>white</td> <td>White (default).</td> </tr>
430  /// <tr> <td></td> <td>red</td> <td>Red.</td> </tr>
431  /// <tr> <td></td> <td>green</td> <td>Green.</td> </tr>
432  /// <tr> <td></td> <td>blue</td> <td>Blue.</td> </tr>
433  /// <tr> <td>[noiseReduction]</td> <td>Amount of noise reduction [0-5].</td> </tr>
434  /// </table>
435  ///
437 
438  /// Gets current SLS params for Coded Light and Phase Shift.
439  ///
440  /// @code
441  /// "method": "david::sls::GetCodedLightPhaseShiftParams"
442  ///
443  /// --> "params" : null
444  /// <-- "result" : {"inverse" : bool, "shifts" : int, "orientation" : string, "brightness" : int, "noiseReduction" : int}
445  /// <-- "error" : {"code" : int, "message" : string}
446  /// @endcode
447  ///
448  /// <b>Return Values</b>
449  /// <table borders="0">
450  /// <tr> <td>inverse</td> <td>Use inverse Coded Light patterns [true|false]. Doubles the amount of Coded Light patterns.</td> </tr>
451  /// <tr> <td>shifts</td> <td>Number of sine patterns (Phase Shift shifts) [3-16].</td> </tr>
452  /// <tr> <td>orientation</td> <td></td> <td>Orientation of SL patterns</td> </tr>
453  /// <tr> <td></td> <td>horizontal</td> <td>Patterns for horizontal setups only (projector and camera are next to each other).</td> </tr>
454  /// <tr> <td></td> <td>vertical</td> <td>Patterns for vertical setups only (projector and camera are above each other).</td> </tr>
455  /// <tr> <td></td> <td>both</td> <td>Both pattern orientations (projector and camera are located diagonally).</td> </tr>
456  /// <tr> <td>brightness</td> <td>Brightness of the projected patterns [0-255].</td> </tr>
457  /// <tr> <td>noiseReduction</td> <td>Amount of noise reduction [0-5].</td> </tr>
458  /// </table>
459  ///s
461 
462  /// Sets the result filtering parameters for SL scans.
463  ///
464  /// @code
465  /// "method": "david::sls::SetResultFiltering"
466  ///
467  /// --> "params" : {"qualityCheck" : double, "backgroundRemovalEnabled" : bool, "backgroundRemovalEpsilon" : double}
468  /// <-- "result" : null
469  /// <-- "error" : {"code" : int, "message" : string}
470  /// @endcode
471  ///
472  /// <b>Parameters</b>
473  /// <table borders="0">
474  /// <tr> <td>qualityCheck</td> <td>Quality threshold for 3D data in [0,1] [optional; default: keep current setting].</td> </tr>
475  /// <tr> <td>backgroundRemovalEnabled</td> <td>Enable background removal true/false [optional; default: keep current setting].</td> </tr>
476  /// <tr> <td>backgroundRemovalEpsilon</td> <td>Background removal epsilon in [mm] [optional; default: keep current setting].</td> </tr>
477  /// <tr> <td>outlierRemoval</td> <td>Outlier filter [0,1]. E.g. 0.1=remove all fragments that are smaller than 10% of the largest fragment. [optional; default: keep current setting].</td> </tr>
478  /// </table>
479  ///
481 
482  /// Gets the result filtering parameters for SL scans.
483  ///
484  /// @code
485  /// "method": "david::sls::GetResultFiltering"
486  ///
487  /// --> "params" : null
488  /// <-- "result" : {"qualityCheck" : double, "backgroundRemovalEnabled" : bool, "backgroundRemovalEpsilon" : double}
489  /// <-- "error" : {"code" : int, "message" : string}
490  /// @endcode
491  ///
492  /// <b>Return Values</b>
493  /// <table borders="0">
494  /// <tr> <td>qualityCheck</td> <td>Quality threshold for 3D data [0,1].</td> </tr>
495  /// <tr> <td>backgroundRemovalEnabled</td> <td>Enable background removal true/false.</td> </tr>
496  /// <tr> <td>backgroundRemovalEpsilon</td> <td>Background removal epsilon in [mm]</td> </tr>
497  /// <tr> <td>outlierRemoval</td> <td>Outlier filter value in [0,1].</td> </tr>
498  /// </table>
499  ///
501 
502  /// Imports calibration parameters of camera and projector from an XML files.
503  ///
504  /// @warning File paths like "c:\\david\\camera.cal" are interpreted as files located on the server.
505  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\david\\camera.cal".
506  ///
507  /// @code
508  /// "method": "david::sls::ImportCalibration"
509  ///
510  /// --> "params" : {"cameraCalibrationFilename" : string, "projectorCalibrationFilename" : string}
511  /// <-- "result" : null
512  /// <-- "error" : {"code" : int, "message" : string}
513  /// @endcode
514  ///
515  /// <b>Parameters</b>
516  /// <table borders="0">
517  /// <tr> <td>cameraCalibrationFilename</td> <td>Filename for importing the camera calibration.</td> </tr>
518  /// <tr> <td>projectorCalibrationFilename</td> <td>Filename for importing the projector calibration.</td> </tr>
519  /// </table>
520  ///
521  /// <b>Error Codes</b>
522  /// <table borders="0">
523  /// <tr> <td>david::Error_CameraCalibration</td> <td>Could not read camera calibration file.</td> </tr>
524  /// <tr> <td>david::Error_ProjectorCalibration</td> <td>Could not read projector calibration file.</td> </tr>
525  /// </table>
526  ///
528 
529  /// Exports the current calibration parameters of camera and projector to XML files.
530  ///
531  /// @warning File paths like "c:\\david\\camera.cal" are interpreted as files located on the server.
532  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\david\\camera.cal".
533  ///
534  /// @code
535  /// "method": "david::sls::ExportCalibration"
536  ///
537  /// --> "params" : {"cameraCalibrationFilename" : string, "projectorCalibrationFilename" : string}
538  /// <-- "result" : null
539  /// <-- "error" : {"code" : int, "message" : string}
540  /// @endcode
541  ///
542  /// <b>Parameters</b>
543  /// <table borders="0">
544  /// <tr> <td>cameraCalibrationFilename</td> <td>Filename for the exported camera calibration.</td> </tr>
545  /// <tr> <td>projectorCalibrationFilename</td> <td>Filename for the exported projector calibration.</td> </tr>
546  /// </table>
547  ///
548  /// <b>Error Codes</b>
549  /// <table borders="0">
550  /// <tr> <td>david::Error_NotCalibrated</td> <td>Scanner is not calibrated.</td> </tr>
551  /// </table>
552  ///
554 
555  /// Triggers automatic calibration of the Structured Light Scanner. The function returns
556  /// when calibration is finished or an error occurred.
557  ///
558  /// @code
559  /// "method": "david::sls::Calibrate"
560  ///
561  /// --> "params" : {"calibScale" : double}
562  /// <-- "result" : null
563  /// <-- "error" : {"code" : int, "message" : string}
564  /// @endcode
565  ///
566  /// <b>Parameters</b>
567  /// <table borders="0">
568  /// <tr> <td>calibScale</td> <td>Scale of the calibration pattern. Typically in mm.</td> </tr>
569  /// </table>
570  ///
571  /// <b>Error Codes</b>
572  /// <table borders="0">
573  /// <tr> <td>david::Error_CameraCalibration</td> <td>Camera calibration failed.</td> </tr>
574  /// <tr> <td>david::Error_ProjectorCalibration</td> <td>Projector calibration failed.</td> </tr>
575  /// <tr> <td>david::Error_NoLiveImage</td> <td>Camera/Grabber is not running.</td> </tr>
576  /// </table>
577  ///
579 
580  /// Triggers a Structured Light Scan. The function returns when
581  /// scanning is finished or an error occurred.
582  ///
583  /// @code
584  /// "method": "david::sls::Scan"
585  ///
586  /// --> "params" : {"grabTexture" : bool, "setAsBackground" : bool}
587  /// <-- "result" : int
588  /// <-- "error" : {"code" : int, "message" : string}
589  /// @endcode
590  ///
591  /// <b>Parameters</b>
592  /// <table borders="0">
593  /// <tr> <td>[grabTexture]</td> <td>Grab a texture with the scan? [optional, default false]</td> </tr>
594  /// <tr> <td>[setAsBackground]</td> <td>Define the new scan as background, for Background Removal (see SetResultFiltering) [optional, default false]</td> </tr>
595  /// </table>
596  ///
597  /// <b>Return Values</b>
598  /// <table borders="0">
599  /// <tr> <td>Number of triangulated 3D points.</td> </tr>
600  /// </table>
601  ///
602  /// <b>Error Codes</b>
603  /// <table borders="0">
604  /// <tr> <td>david::Error_NotCalibrated</td> <td>Cannot scan because scanner is not calibrated.</td> </tr>
605  /// <tr> <td>david::Error_NoLiveImage</td> <td>Camera/Grabber is not running.</td> </tr>
606  /// </table>
607  ///
609 
610  /// Grabs a new texture.
611  ///
612  /// @code
613  /// "method": "david::sls::GrabTexture"
614  ///
615  /// --> "params" : null
616  /// <-- "result" : null
617  /// <-- "error" : {"code" : int, "message" : string}
618  /// @endcode
619  ///
620  /// <b>Error Codes</b>
621  /// <table borders="0">
622  /// <tr> <td>david::Error_NoLiveImage</td> <td>Camera/Grabber is not running.</td> </tr>
623  /// </table>
624  ///
626 
627  /// Executes an auto white balancing procedure.
628  ///
629  /// @code
630  /// "method": "david::sls::AutoWhiteBalance"
631  ///
632  /// --> "params" : null
633  /// <-- "result" : null
634  /// <-- "error" : {"code" : int, "message" : string}
635  /// @endcode
636  ///
637  /// <b>Error Codes</b>
638  /// <table borders="0">
639  /// <tr> <td>david::Error_NoLiveImage</td> <td>Camera/Grabber is not running.</td> </tr>
640  /// </table>
641  ///
643 
644  /// Adds the current scan to 'Shape Fusion' module.
645  ///
646  /// @code
647  /// "method": "david::sls::AddScanToShapeFusion"
648  ///
649  /// --> "params" : null
650  /// <-- "result" : int
651  /// <-- "error" : {"code" : int, "message" : string}
652  /// @endcode
653  ///
654  /// <b>Return Values</b>
655  /// <table borders="0">
656  /// <tr> <td>ID of the mesh.</td> </tr>
657  /// </table>
658  ///
659  /// <b>Error Codes</b>
660  /// <table borders="0">
661  /// <tr> <td>david::Error_MissingObject</td> <td>No scan data at hand.</td> </tr>
662  /// </table>
663  ///
665 
666  /// Exports the scan as a mesh. See documentation of DAVID software for supported file formats.
667  /// Note: If SDK Server is not licensed, the resulting OBJ file will have reduced mesh resolution (like Free Edition).
668  ///
669  /// @warning File paths like "c:\\meshes\\myobject.obj" are interpreted as files located on the server.
670  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\meshes\\myobject.obj".
671  ///
672  /// @code
673  /// "method": "david::sls::ExportMesh"
674  ///
675  /// --> "params" : {"filename" : string}
676  /// <-- "result" : null
677  /// <-- "error" : {"code" : int, "message" : string}
678  /// @endcode
679  ///
680  /// <b>Parameters</b>
681  /// <table borders="0">
682  /// <tr> <td>filename</td> <td>Filename of the mesh to be exported.</td> </tr>
683  /// </table>
684  ///
685  /// <b>Error Codes</b>
686  /// <table borders="0">
687  /// <tr> <td>david::Error_InvalidPath</td> <td>Export path invalid.</td> </tr>
688  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Export target directory does not exist.</td> </tr>
689  /// <tr> <td>david::Error_MissingFilename</td> <td>Export path misses file name.</td> </tr>
690  /// <tr> <td>david::Error_MissingObject</td> <td>No scan data at hand.</td> </tr>
691  /// </table>
692  ///
694 
695  /// Exports the current background scan as depthmap (PFM file).
696  /// Note: If SDK Server is not licensed, this function will not run.
697  ///
698  /// @warning File paths like "c:\\meshes\\background.pfm" are interpreted as files located on the server.
699  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\meshes\\background.pfm".
700  ///
701  /// @code
702  /// "method": "david::sls::ExportBackgroundDepthmap"
703  ///
704  /// --> "params" : {"filename" : string}
705  /// <-- "result" : null
706  /// <-- "error" : {"code" : int, "message" : string}
707  /// @endcode
708  ///
709  /// <b>Parameters</b>
710  /// <table borders="0">
711  /// <tr> <td>filename</td> <td>Filename of the depthmap to be exported (must end with .pfm).</td> </tr>
712  /// </table>
713  ///
714  /// <b>Error Codes</b>
715  /// <table borders="0">
716  /// <tr> <td>david::Error_InvalidPath</td> <td>Export path invalid.</td> </tr>
717  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Export target directory does not exist.</td> </tr>
718  /// <tr> <td>david::Error_MissingFilename</td> <td>Export path misses file name.</td> </tr>
719  /// <tr> <td>david::Error_MissingObject</td> <td>No background data at hand.</td> </tr>
720  /// <tr> <td>david::Error_NotLicensed</td> <td>SDK Server is not licensed to save.</td> </tr>
721  /// </table>
722  ///
724 
725  /// Imports a background scan from a depthmap (PFM file).
726  ///
727  /// @warning File paths like "c:\\meshes\\background.pfm" are interpreted as files located on the server.
728  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\meshes\\background.pfm".
729  ///
730  /// @code
731  /// "method": "david::sls::ImportBackgroundDepthmap"
732  ///
733  /// --> "params" : {"filename" : string}
734  /// <-- "result" : null
735  /// <-- "error" : {"code" : int, "message" : string}
736  /// @endcode
737  ///
738  /// <b>Parameters</b>
739  /// <table borders="0">
740  /// <tr> <td>filename</td> <td>Filename of the depthmap to be imported (must end with .pfm).</td> </tr>
741  /// </table>
742  ///
743  /// <b>Error Codes</b>
744  /// <table borders="0">
745  /// <tr> <td>david::Error_InvalidPath</td> <td>Export path invalid.</td> </tr>
746  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Export target directory does not exist.</td> </tr>
747  /// <tr> <td>david::Error_MissingFilename</td> <td>Export path misses file name.</td> </tr>
748  /// </table>
749  ///
751 };
752 
753 /// A list of supported JSON RPC 2.0 functions in namespace david::turntable.
754 ///
756 {
757  /// Connects or disconnects a turntable.
758  ///
759  /// @code
760  /// "method": "david::turntable::Setup"
761  ///
762  /// --> "params" : {"enable" : bool}
763  /// <-- "result" : null
764  /// <-- "error" : {"code" : int, "message" : string}
765  /// @endcode
766  ///
767  /// <b>Parameters</b>
768  /// <table borders="0">
769  /// <tr> <td>enable</td> <td>True for connect, false for disconnect.</td> </tr>
770  /// </table>
771  ///
772  /// <b>Error Codes</b>
773  /// <table borders="0">
774  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Turntable not available</td> </tr>
775  /// </table>
776  ///
778 
779  /// Rotates the turntable. The turntable rotates counterclockwise ('degrees' is postive) or clockwise ('degrees' is negative).
780  ///
781  /// @code
782  /// "method": "david::turntable::Rotate"
783  ///
784  /// --> "params" : {"degrees" : double}
785  /// <-- "result" : null
786  /// <-- "error" : {"code" : int, "message" : string}
787  /// @endcode
788  ///
789  /// <b>Parameters</b>
790  /// <table borders="0">
791  /// <tr> <td>degrees</td> <td>Amount of rotation in degrees.</td> </tr>
792  /// </table>
793  ///
794  /// <b>Error Codes</b>
795  /// <table borders="0">
796  /// <tr> <td>david::Error_DeviceNotAvailable</td> <td>Turntable not available</td> </tr>
797  /// <tr> <td>david::Error_Fail</td> <td>Rotation of turntable failed.</td> </tr>
798  /// </table>
799  ///
801 };
802 
803 /// A list of supported JSON RPC 2.0 functions in namespace david::shapefusion.
804 ///
806 {
807  /// Imports a mesh into the mesh list from a file given by 'filename'. See documentation of DAVID software for supported file formats.
808  ///
809  /// @warning File paths like "c:\\meshes\\myobject.obj" are interpreted as files located on the server.
810  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\meshes\\myobject.obj".
811  ///
812  /// @code
813  /// "method": "david::shapefusion::ImportMesh"
814  ///
815  /// --> "params" : {"filename" : string}
816  /// <-- "result" : int
817  /// <-- "error" : {"code" : int, "message" : string}
818  /// @endcode
819  ///
820  /// <b>Parameters</b>
821  /// <table borders="0">
822  /// <tr> <td>filename</td> <td>Filename of the mesh to be imported.</td> </tr>
823  /// </table>
824  ///
825  /// <b>Return Values</b>
826  /// <table borders="0">
827  /// <tr> <td>ID of the mesh.</td> </tr>
828  /// </table>
829  ///
830  /// <b>Error Codes</b>
831  /// <table borders="0">
832  /// <tr> <td>david::Error_NoAccess</td> <td>No access to path.</td> </tr>
833  /// <tr> <td>david::Error_InvalidPath</td> <td>Specified path is invalid.</td> </tr>
834  /// <tr> <td>david::Error_MissingFilename</td> <td>Specified path misses file name.</td> </tr>
835  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Specified directory does not exist.</td> </tr>
836  /// <tr> <td>david::Error_FileNotFound</td> <td>Specified file does not exist.</td> </tr>
837  /// </table>
838  ///
840 
841  /// Exports a mesh. This mesh can be an item of the scan list or the fusion result. Just provide a valid 'meshID'.
842  /// See documentation of DAVID software for supported file formats.
843  /// Note: If SDK Server is not licensed, saving will not be possible, and david::Error_NotLicensed will be returned.
844  ///
845  /// @warning File paths like "c:\\meshes\\myobject.obj" are interpreted as files located on the server.
846  /// For files located on the client you have to use a shared network path like "\\\\mycomputer\\meshes\\myobject.obj".
847  ///
848  /// @code
849  /// "method": "david::shapefusion::ExportMesh"
850  ///
851  /// --> "params" : {"meshID" : int, "filename" : string}
852  /// <-- "result" : null
853  /// <-- "error" : {"code" : int, "message" : string}
854  /// @endcode
855  ///
856  /// <b>Parameters</b>
857  /// <table borders="0">
858  /// <tr> <td>meshID</td> <td>ID of the mesh to be exported.</td> </tr>
859  /// <tr> <td>filename</td> <td>Filename of the mesh to be exported.</td> </tr>
860  /// </table>
861  ///
862  /// <b>Error Codes</b>
863  /// <table borders="0">
864  /// <tr> <td>david::Error_NoAccess</td> <td>No access to path.</td> </tr>
865  /// <tr> <td>david::Error_InvalidPath</td> <td>Specified path is invalid.</td> </tr>
866  /// <tr> <td>david::Error_MissingFilename</td> <td>Specified path misses file name.</td> </tr>
867  /// <tr> <td>david::Error_DirectoryNotFound</td> <td>Specified directory does not exist.</td> </tr>
868  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
869  /// <tr> <td>david::Error_NotLicensed</td> <td>SDK Server is not licensed to save.</td> </tr>
870  /// </table>
871  ///
873 
874  /// Duplicate mesh with mesh ID 'sourceMeshID'.
875  ///
876  /// @code
877  /// "method": "david::shapefusion::DuplicateMesh"
878  ///
879  /// --> "params" : {"sourceMeshID" : int}
880  /// <-- "result" : int
881  /// <-- "error" : {"code" : int, "message" : string}
882  /// @endcode
883  ///
884  /// <b>Parameters</b>
885  /// <table borders="0">
886  /// <tr> <td>sourceMeshID</td> <td>ID of the mesh to be duplicated.</td> </tr>
887  /// </table>
888  ///
889  /// <b>Return Values</b>
890  /// <table borders="0">
891  /// <tr> <td>ID of the newly created mesh.</td> </tr>
892  /// </table>
893  ///
894  /// <b>Error Codes</b>
895  /// <table borders="0">
896  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
897  /// </table>
898  ///
900 
901  /// Deletes all meshes in 'Shape Fusion'.
902  ///
903  /// @code
904  /// "method": "david::shapefusion::DeleteAllMeshes"
905  ///
906  /// --> "params" : null
907  /// <-- "result" : null
908  /// <-- "error" : {"code" : int, "message" : string}
909  /// @endcode
910  ///
912 
913  /// Deletes a specific mesh of the mesh list.
914  ///
915  /// @code
916  /// "method": "david::shapefusion::DeleteMesh"
917  ///
918  /// --> "params" : {"meshID" : int}
919  /// <-- "result" : null
920  /// <-- "error" : {"code" : int, "message" : string}
921  /// @endcode
922  ///
923  /// <b>Parameters</b>
924  /// <table borders="0">
925  /// <tr> <td>meshID</td> <td>ID of the mesh.</td> </tr>
926  /// </table>
927  ///
928  /// <b>Error Codes</b>
929  /// <table borders="0">
930  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
931  /// </table>
932  ///
934 
935  /// Gets a selected data (array buffer like vertex positions) from a specified mesh.
936  /// Note: If SDK Server is not licensed, part of the vertex coordinates / normals (sent over binary channel) will be ZEROES only.
937  ///
938  /// @code
939  /// "method": "david::shapefusion::GetMeshBuffer"
940  ///
941  /// --> "params" : {"meshID" : int, "bufferType" : string}
942  /// <-- "result" : {"vertexCount": uint32_t, "triangleCount:" uint32_t, "size" : uint32_t}
943  /// <-- "error" : {"code" : int, "message" : string}
944  /// @endcode
945  ///
946  /// <b>Parameters</b>
947  /// <table borders="0">
948  /// <tr> <td>meshID</td> <td></td> <td>ID of the mesh that owns the requested buffer.</td> </tr>
949  /// <tr> <td>bufferType</td> <td></td> <td>Type of the buffer to be transmitted over binary channel:</td> </tr>
950  /// <tr> <td></td> <td>VertexPositions</td> <td>Positions of all vertices as float triples (x,y,z).</td> </tr>
951  /// <tr> <td></td> <td>VertexNormals</td> <td>Normals of all vertices as float triples (nx,ny,nz).</td> </tr>
952  /// <tr> <td></td> <td>VertexTexCoords</td> <td>Texture coordinates of all vertices as float pairs (u,v).</td> </tr>
953  /// <tr> <td></td> <td>Triangles</td> <td>Triangle indices (indexed face set) as int32_t triples (id1,id2,id3).</td> </tr>
954  /// <tr> <td>[coordinateSystem]</td> <td></td> <td>Coordinates should be relative to which coordinate system. World is assumed by default.</td></tr>
955  /// <tr> <td></td> <td>WorldCoordinates</td> <td>Coordinates are given with respect to world (global coordinates).</td></tr>
956  /// <tr> <td></td> <td>LocalCoordinates</td> <td>Coordinates are given with respect to local object coordinate system.</td></tr>
957  /// </table>
958  ///
959  /// <b>Return Values</b>
960  /// <table borders="0">
961  /// <tr> <td>vertexCount</td> <td>Number of vertices for requested mesh.</td> </tr>
962  /// <tr> <td>triangleCount</td> <td>Number of triangles for requested mesh.</td> </tr>
963  /// <tr> <td>size</td> <td>Size of the buffer in bytes to be transmitted over binary channel.</td> </tr>
964  /// </table>
965  ///
966  /// <b>Error Codes</b>
967  /// <table borders="0">
968  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
969  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid buffer type.</td> </tr>
970  /// </table>
971  ///
973 
974  /// Gets the texture image of a mesh as binary data. Each pixel is represented by 3 bytes in BGR order. The pixels are ordered row by row, from top to bottom, each row from left to right. The data size is (3*width*height) bytes.
975  ///
976  /// @code
977  /// "method": "david::shapefusion::GetTextureImage"
978  ///
979  /// --> "params" : {"meshID" : int, "sendData" : bool}
980  /// <-- "result" : {"width": uint32_t, "height:" uint32_t, "size" : uint32_t}
981  /// <-- "error" : {"code" : int, "message" : string}
982  /// @endcode
983  ///
984  /// <b>Parameters</b>
985  /// <table borders="0">
986  /// <tr> <td>meshID</td> <td></td> <td>ID of the mesh that owns the requested buffer.</td> </tr>
987  /// <tr> <td>sendData</td> <td></td> <td>Send image data over binary channel?</td> </tr>
988  /// </table>
989  ///
990  /// <b>Return Values</b>
991  /// <table borders="0">
992  /// <tr> <td>width</td> <td>Width of the texture image in [px].</td> </tr>
993  /// <tr> <td>height</td> <td>Height of the texture image in [px].</td> </tr>
994  /// <tr> <td>size</td> <td>Size of the buffer in bytes to be transmitted over binary channel.</td> </tr>
995  /// </table>
996  ///
997  /// <b>Error Codes</b>
998  /// <table borders="0">
999  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1000  /// <tr> <td>david::Error_MissingObject</td> <td>Specified mesh has no texture.</td> </tr>
1001  /// </table>
1002  ///
1004 
1005  /// Gets the current transformation (position+rotation) of a mesh. Initially, an imported mesh has no transformation. The transformation depends on previous calls of the Align... functions, or the Rotate or Translate functions.
1006  /// The position is returned in vector (px, py, pz). The rotation is returned in three different representations which are equivalent: A rotation matrix (n,o,a), roll-pitch-yaw angles, and a quaternion.
1007  /// Note: If SDK Server is not licensed, this function will return the error code david::Error_NotLicensed.
1008  ///
1009  /// @code
1010  /// "method": "david::shapefusion::GetPose"
1011  ///
1012  /// --> "params" : {"meshID" : int}
1013  /// <-- "result" : {"px": double, "py": double, "pz": double,
1014  /// "nx": double, "ny": double, "nz": double,
1015  /// "ox": double, "oy": double, "oz": double,
1016  /// "ax": double, "ay": double, "az": double,
1017  /// "roll": double, "pitch": double, "yaw": double,
1018  /// "quat0": double, "quat1": double, "quat2": double, "quat3": double}
1019  /// <-- "error" : {"code" : int, "message" : string}
1020  /// @endcode
1021  ///
1022  /// <b>Parameters</b>
1023  /// <table borders="0">
1024  /// <tr> <td>meshID</td> <td></td> <td>ID of the mesh whose pose to retrieve.</td> </tr>
1025  /// </table>
1026  ///
1027  /// <b>Return Values</b>
1028  /// <table borders="0">
1029  /// <tr> <td>px, py, pz</td> <td>position vector of the current mesh pose.</td> </tr>
1030  /// <tr> <td>nx, ny, nz</td> <td>1st column of the rotation matrix.</td> </tr>
1031  /// <tr> <td>ox, oy, oz</td> <td>2nd column of the rotation matrix.</td> </tr>
1032  /// <tr> <td>ax, ay, az</td> <td>3rd column of the rotation matrix.</td> </tr>
1033  /// <tr> <td>roll, pitch, yaw</td> <td>roll, pitch, yaw angles in [RAD], assuming this multiplication order: RotZ(yaw)*RotY(pitch)*RotX(roll).</td> </tr>
1034  /// <tr> <td>quat0, quat1, quat2, quat3</td> <td>Quaternion represention of the mesh rotation (quat0 + i*quat1 + j*quat2 + k*quat3).</td> </tr>
1035  /// </table>
1036  ///
1037  /// <b>Error Codes</b>
1038  /// <table borders="0">
1039  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1040  /// <tr> <td>david::Error_NotLicensed</td> <td>SDK Server is not licensed.</td> </tr>
1041  /// </table>
1042  ///
1044 
1045  /// Sets the current transformation (position+rotation) of a mesh. Initially, an imported mesh has no transformation. The transformation depends on previous calls of the Align... functions, or the Rotate or Translate functions.
1046  /// The position is returned in vector (px, py, pz). The rotation is returned in three different representations which are equivalent: A rotation matrix (n,o,a), roll-pitch-yaw angles, and a quaternion.
1047  /// Note: If SDK Server is not licensed, this function will return the error code david::Error_NotLicensed.
1048  ///
1049  /// @code
1050  /// "method": "david::shapefusion::SetPose"
1051  ///
1052  /// --> "params" : {"meshID" : int,
1053  /// "px": double, "py": double, "pz": double,
1054  /// "nx": double, "ny": double, "nz": double,
1055  /// "ox": double, "oy": double, "oz": double,
1056  /// "ax": double, "ay": double, "az": double}
1057  /// <-- "result" : null
1058  /// <-- "error" : {"code" : int, "message" : string}
1059  /// @endcode
1060  ///
1061  /// <b>Parameters</b>
1062  /// <table borders="0">
1063  /// <tr> <td>meshID</td> <td>ID of the mesh whose pose to retrieve.</td> </tr>
1064  /// <tr> <td>px, py, pz</td> <td>position vector of the current mesh pose.</td> </tr>
1065  /// <tr> <td>nx, ny, nz</td> <td>1st column of the rotation matrix.</td> </tr>
1066  /// <tr> <td>ox, oy, oz</td> <td>2nd column of the rotation matrix.</td> </tr>
1067  /// <tr> <td>ax, ay, az</td> <td>3rd column of the rotation matrix.</td> </tr>
1068  /// </table>
1069  ///
1070  /// <b>Error Codes</b>
1071  /// <table borders="0">
1072  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1073  /// <tr> <td>david::Error_NotLicensed</td> <td>SDK Server is not licensed.</td> </tr>
1074  /// </table>
1075  ///
1077 
1078  /// Rotates a mesh around specified axis by given degrees.
1079  ///
1080  /// @code
1081  /// "method": "david::shapefusion::Rotate"
1082  ///
1083  /// --> "params" : {"meshID" : int, "transformType" : string, "degrees" : double }
1084  /// <-- "result" : null
1085  /// <-- "error" : {"code" : int, "message" : string}
1086  /// @endcode
1087  ///
1088  /// <b>Parameters</b>
1089  /// <table borders="0">
1090  /// <tr> <td>meshID</td> <td></td> <td>ID of mesh to be transformed.</td> </tr>
1091  /// <tr> <td>transformType</td> <td></td> <td>Selects axis and coordinate system of rotation:</td> </tr>
1092  /// <tr> <td></td> <td>TransformGlobalX</td> <td>Rotate around global (world) x axis.</td> </tr>
1093  /// <tr> <td></td> <td>TransformGlobalY</td> <td>Rotate around global (world) y axis.</td> </tr>
1094  /// <tr> <td></td> <td>TransformGlobalZ</td> <td>Rotate around global (world) z axis.</td> </tr>
1095  /// <tr> <td></td> <td>TransformMeshX</td> <td>Rotate around mesh's x axis.</td> </tr>
1096  /// <tr> <td></td> <td>TransformMeshY</td> <td>Rotate around mesh's y axis.</td> </tr>
1097  /// <tr> <td></td> <td>TransformMeshZ</td> <td>Rotate around mesh's z axis.</td> </tr>
1098  /// <tr> <td>degrees</td> <td></td> <td>Amount of rotation in degrees</td> </tr>
1099  /// </table>
1100  ///
1101  /// <b>Error Codes</b>
1102  /// <table borders="0">
1103  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1104  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid transform type.</td> </tr>
1105  /// </table>
1106  ///
1108 
1109  /// Translates a mesh along specified axis by given degrees.
1110  ///
1111  /// @code
1112  /// "method": "david::shapefusion::Translate"
1113  ///
1114  /// --> "params" : {"meshID" : int, "transformType" : string, "amount" : double }
1115  /// <-- "result" : null
1116  /// <-- "error" : {"code" : int, "message" : string}
1117  /// @endcode
1118  ///
1119  /// <b>Parameters</b>
1120  /// <table borders="0">
1121  /// <tr> <td>meshID</td> <td></td> <td>ID of mesh to be transformed.</td> </tr>
1122  /// <tr> <td>transformType</td> <td></td> <td>Selects axis and coordinate system of translation:</td> </tr>
1123  /// <tr> <td></td> <td>TransformGlobalX</td> <td>Translate along global (world) x axis.</td> </tr>
1124  /// <tr> <td></td> <td>TransformGlobalY</td> <td>Translate along global (world) y axis.</td> </tr>
1125  /// <tr> <td></td> <td>TransformGlobalZ</td> <td>Translate along global (world) z axis.</td> </tr>
1126  /// <tr> <td></td> <td>TransformMeshX</td> <td>Translate along mesh's x axis.</td> </tr>
1127  /// <tr> <td></td> <td>TransformMeshY</td> <td>Translate along mesh's y axis.</td> </tr>
1128  /// <tr> <td></td> <td>TransformMeshZ</td> <td>Translate along mesh's z axis.</td> </tr>
1129  /// <tr> <td>amount</td> <td></td> <td>Amount of translation. Typically in mm.</td> </tr>
1130  /// </table>
1131  ///
1132  /// <b>Error Codes</b>
1133  /// <table borders="0">
1134  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1135  /// <tr> <td>david::Error_RpcInvalidParams</td> <td>Invalid transform type.</td> </tr>
1136  /// </table>
1137  ///
1139 
1140  /// Reduces the density of a mesh.
1141  ///
1142  /// @code
1143  /// "method": "david::shapefusion::ReduceMeshDensity"
1144  ///
1145  /// --> "params" : {"meshID" : int, "factor" : float }
1146  /// <-- "result" : null
1147  /// <-- "error" : {"code" : int, "message" : string}
1148  /// @endcode
1149  ///
1150  /// <b>Parameters</b>
1151  /// <table borders="0">
1152  /// <tr> <td>meshID</td> <td></td> <td>ID of mesh to be reduced.</td> </tr>
1153  /// <tr> <td>factor</td> <td></td> <td>Factor of reduction, between 0 and 1.</td> </tr>
1154  /// </table>
1155  ///
1156  /// <b>Error Codes</b>
1157  /// <table borders="0">
1158  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1159  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid factor value.</td> </tr>
1160  /// </table>
1161  ///
1163 
1164  /// Combines several meshes into one group.
1165  ///
1166  /// @code
1167  /// "method": "david::shapefusion::CombineMeshes"
1168  ///
1169  /// --> "params" : {"meshIDs" : int[]}
1170  /// <-- "result" : int
1171  /// <-- "error" : {"code" : int, "message" : string}
1172  /// @endcode
1173  ///
1174  /// <b>Parameters</b>
1175  /// <table borders="0">
1176  /// <tr> <td>meshIDs</td> <td></td> <td>IDs of the meshes to be combined (must contain at least 2 IDs).</td> </tr>
1177  /// </table>
1178  ///
1179  /// <b>Return Values</b>
1180  /// <table borders="0">
1181  /// <tr> <td>Mesh ID of the combined mesh.</td> </tr>
1182  /// </table>
1183  ///
1184  /// <b>Error Codes</b>
1185  /// <table borders="0">
1186  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1187  /// <tr> <td>david::Error_InvalidArgument</td> <td>Invalid number of IDs.</td> </tr>
1188  /// </table>
1189  ///
1191 
1192  /// Uncombines a groups of meshes into seperate meshes.
1193  ///
1194  /// @code
1195  /// "method": "david::shapefusion::UncombineMeshes"
1196  ///
1197  /// --> "params" : {"meshID" : int}
1198  /// <-- "result" : int[]
1199  /// <-- "error" : {"code" : int, "message" : string}
1200  /// @endcode
1201  ///
1202  /// <b>Parameters</b>
1203  /// <table borders="0">
1204  /// <tr> <td>meshID</td> <td></td> <td>ID of the mesh group to be uncombined.</td> </tr>
1205  /// </table>
1206  ///
1207  /// <b>Return Values</b>
1208  /// <table borders="0">
1209  /// <tr> <td>Array of Mesh IDs of the separated meshes.</td> </tr>
1210  /// </table>
1211  ///
1212  /// <b>Error Codes</b>
1213  /// <table borders="0">
1214  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist, or is no group.</td> </tr>
1215  /// </table>
1216  ///
1218 
1219  /// Coarse alignment of a pair of meshes.
1220  ///
1221  /// @code
1222  /// "method": "david::shapefusion::AlignPairCoarse"
1223  ///
1224  /// --> "params" : {"meshID1" : int,
1225  /// "meshID2" : int,
1226  /// "texturePercentage" : int,
1227  /// "motionInfo" : {"angleKnown" : bool,
1228  /// "axisDirKnown" : bool,
1229  /// "angle" : double,
1230  /// "angleTolerance" : double,
1231  /// "axisDir" : [double,double,double]},
1232  /// "qualityFactor" : float }
1233  /// <-- "result" : double
1234  /// <-- "error" : {"code" : int, "message" : string}
1235  /// @endcode
1236  ///
1237  /// <b>Parameters</b>
1238  /// <table borders="0">
1239  /// <tr> <td>meshID1</td> <td></td> <td>ID of the mesh that is to be aligned.</td> </tr>
1240  /// <tr> <td>meshID2</td> <td></td> <td>ID of the other mesh.</td> </tr>
1241  /// <tr> <td>[texturePercentage]</td> <td></td> <td>Percentage of texture influence on alignment (0-99). Only used if value is higher than 0 [optional, default 0].</td> </tr>
1242  /// <tr> <td>[motionInfo]</td> <td></td> <td>MotionInfo: Additional information about motion between two meshes [optional].</td> </tr>
1243  /// <tr> <td></td> <td>angleKnown</td> <td>Is rotation 'angle' around motion axis known?</td> </tr>
1244  /// <tr> <td></td> <td>axisDirKnown</td> <td>Is direction vector 'axisDir' of motion axis is known?</td> </tr>
1245  /// <tr> <td></td> <td>angle</td> <td>Angle of rotation in degrees.</td> </tr>
1246  /// <tr> <td></td> <td>angleTolerance</td> <td>Tolerance of angle in degrees.</td> </tr>
1247  /// <tr> <td></td> <td>axisDir</td> <td>3D direction vector (x,y,z) of motion axis w.r.t. world coordinates.</td> </tr>
1248  /// <tr> <td>[qualityFactor]</td> <td></td> <td>Quality parameter for alignment. 1 is recommended. Larger values like 5 or 10 may create better results for symmetric objects, but increase computation time. Lower values like 0.01 to 0.1 decrease computation time, but may result in wrong alignment results [optional, default 1].</td> </tr>
1249  /// </table>
1250  ///
1251  /// <b>Return Values</b>
1252  /// <table borders="0">
1253  /// <tr> <td>Quality of alignment result as percentage of contact, in range [0,100]=[bad,good].</td> </tr>
1254  /// </table>
1255  ///
1256  /// <b>Error Codes</b>
1257  /// <table borders="0">
1258  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1259  /// </table>
1260  ///
1262 
1263  /// Fine alignment of a pair of meshes.
1264  ///
1265  /// @code
1266  /// "method": "david::shapefusion::AlignPairFine"
1267  ///
1268  /// --> "params" : {"meshID1" : int, "meshID2" : int, "texturePercentage" : int, "maxNumIterations" : int}
1269  /// <-- "result" : null
1270  /// <-- "error" : {"code" : int, "message" : string}
1271  /// @endcode
1272  ///
1273  /// <b>Parameters</b>
1274  /// <table borders="0">
1275  /// <tr> <td>meshID1</td> <td></td> <td></td> <td>ID of the mesh that is to be aligned.</td> </tr>
1276  /// <tr> <td>meshID2</td> <td></td> <td></td> <td>ID of the other mesh.</td> </tr>
1277  /// <tr> <td>[texturePercentage]</td> <td></td> <td></td> <td>Percentage of texture influence on alignment (0-99). Only used if value is higher than 0 [optional, default 0].</td> </tr>
1278  /// <tr> <td>[maxNumIterations]</td> <td></td> <td></td> <td>Maximum number of iterations to run [optional, default 100].</td> </tr>
1279  /// <tr> <td>[maxTranslation]</td> <td></td> <td></td> <td>Maximum allowed drift[mm] of mesh center [optional, default = 0 = no limit]. Alignment will stop when this limit is reached.</td> </tr>
1280  /// <tr> <td>[maxRotation_deg]</td> <td></td> <td></td> <td>Maximum allowed rotation of mesh in degree [optional, default = 0 = no limit]. Alignment will stop when this limit is reached.</td> </tr>
1281  /// </table>
1282  ///
1283  /// <b>Error Codes</b>
1284  /// <table borders="0">
1285  /// <tr> <td>david::Error_InvalidMeshId</td> <td>Specified meshID does not exist.</td> </tr>
1286  /// </table>
1287  ///
1289 
1290  /// Global fine alignment of all visible meshes.
1291  ///
1292  /// @code
1293  /// "method": "david::shapefusion::AlignGlobalFine"
1294  ///
1295  /// --> "params" : {"texturePercentage" : int, "numIterations" : int}
1296  /// <-- "result" : null
1297  /// <-- "error" : {"code" : int, "message" : string}
1298  /// @endcode
1299  ///
1300  /// <b>Parameters</b>
1301  /// <table borders="0">
1302  /// <tr> <td>[texturePercentage]</td> <td></td> <td>Percentage of texture influence on alignment (only used if value is higher than 0 [optional, default 0].</td> </tr>
1303  /// <tr> <td>[numIterations]</td> <td></td> <td>Number of iterations to run [optional, default 20].</td> </tr>
1304  /// <tr> <td>[maxTranslation]</td> <td></td> <td>Maximum allowed drift[mm] of any mesh center [optional, default = 0 = no limit]. Global Fine Alignment will not rotate any scan more than this.</td> </tr>
1305  /// <tr> <td>[maxRotation_deg]</td> <td></td> <td>Maximum allowed rotation[deg] of any mesh in degree [optional, default = 0 = no limit]. Global Fine Alignment will not rotate any scan more than this.</td> </tr>
1306  /// </table>
1307  ///
1309 
1310  /// Fuses all visible meshes of the mesh list.
1311  ///
1312  /// @code
1313  /// "method": "david::shapefusion::Fuse"
1314  ///
1315  /// --> "params" : {"resolution" : int, "closeHoles" : bool, "sharpness" : int}
1316  /// <-- "result" : int
1317  /// <-- "error" : {"code" : int, "message" : string}
1318  /// @endcode
1319  ///
1320  /// <b>Parameters</b>
1321  /// <table borders="0">
1322  /// <tr> <td>resolution</td> <td>Limits the maximum resolution and thus the required memory usage.</td> </tr>
1323  /// <tr> <td>holeSizeThresRel</td> <td>Holes, which have a smaller area than holeSizeThresRel * size of original data surface, will be closed. 0 = open all holes. 1 = close all holes.</td> </tr>
1324  /// <tr> <td>sharpness</td> <td>Fusion sharpness in [-3,+5]. Negative values for smoothing. Default 1.</td> </tr>
1325  /// </table>
1326  ///
1327  /// <b>Return Values</b>
1328  /// <table borders="0">
1329  /// <tr> <td>Mesh ID of the fusion result.</td> </tr>
1330  /// </table>
1331  ///
1333 };
1334 
1335 
1336 /// A list of supported JSON RPC 2.0 functions in namespace david::measure.
1337 ///
1339 {
1340  /// Computes signed distance values for each vertex of 'MeasureTestObject' relative to 'MeasureReferenceObject'.
1341  /// Note: If SDK Server is not licensed, part of the distance values (sent over binary channel) will be ZEROES only.
1342  ///
1343  /// @code
1344  /// "method": "david::measure::ComputeSurfaceDistances"
1345  ///
1346  /// --> "params" : {"meshID1" : int, "meshID2" : int, "distThresh" : double}
1347  /// <-- "result" : {"vertexCount": uint32_t, "size" : uint32_t}
1348  /// <-- "error" : {"code" : int, "message" : string}
1349  /// @endcode
1350  ///
1351  /// <b>Parameters</b>
1352  /// <table borders="0">
1353  /// <tr> <td>meshID1</td> <td>ID of the mesh that is the test object.</td> </tr>
1354  /// <tr> <td>meshID2</td> <td>ID of the other mesh that is the reference object.</td> </tr>
1355  /// <tr> <td>distThresh</td> <td>Distance threshold: Distance values are limited to the range [-distThresh, distThresh].</td> </tr>
1356  /// </table>
1357  ///
1358  /// <b>Return Values</b>
1359  /// <table borders="0">
1360  /// <tr> <td>vertexCount</td> <td>Number of vertices for mesh</td> </tr>
1361  /// <tr> <td>size</td> <td>Size of float array in bytes to be transmitted over binary channel.</td> </tr>
1362  /// </table>
1363  ///
1364  /// <b>Error Codes</b>
1365  /// <table borders="0">
1366  /// <tr> <td>david::Error_InvalidMeshId</td> <td>One or both of the mesh IDs was invalid.</td> </tr>
1367  /// </table>
1368  ///
1370 
1371 };
1372 
1373 
1374 /// @} // JsonRpcGroup
1375 /// @} // LowLevelGroup
1376 
1377 } // namespace
1378 } // namespace
1379 
1380 #endif // DAVID_SDK_JSON_RPC_FUNCTIONS_H