three.scanner

  1# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  2# This file is Auto Generated by generateScannerPy.py. Do not edit this file manually.
  3# Modifications should be made to _scanner.py and then run generateScannerPy.py to update this file.
  4# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  5
  6## @package three
  7# @file scanner.py
  8# @brief Scanner class to wrap websocket connection. This file will be copied and amended with the three methods.
  9# @date 2024-11-27
 10# @copyright © 2024 Matter and Form. All rights reserved.
 11
 12from MF.V3 import Three
 13from MF.V3.Task import Task
 14from MF.V3.Settings.Align import Align
 15from MF.V3.Settings.AutoFocus import AutoFocus
 16from MF.V3.Settings.ScanSelection import ScanSelection
 17from MF.V3.Settings.CaptureImage import CaptureImage
 18from MF.V3.Settings.Camera import Camera
 19from MF.V3.Settings.Projector import Projector
 20from MF.V3.Settings.Turntable import Turntable
 21from MF.V3.Settings.Capture import Capture
 22from MF.V3.Settings.Scan import Scan
 23from MF.V3.Settings.Export import Export
 24from MF.V3.Settings.Import import Import
 25from MF.V3.Settings.Merge import Merge
 26from MF.V3.Settings.ScanData import ScanData
 27from MF.V3.Settings.Smooth import Smooth
 28from MF.V3.Settings.Advanced import Advanced
 29from MF.V3.Settings.I18n import I18n
 30from MF.V3.Settings.Style import Style
 31from MF.V3.Settings.Tutorials import Tutorials
 32from MF.V3.Settings.Viewer import Viewer
 33from MF.V3.Settings.Software import Software
 34
 35from typing import Any, Callable, Optional, List
 36import websocket
 37import json
 38import threading
 39import time
 40from MF.V3 import Task, TaskState, Buffer
 41from three import __version__
 42import three.MF
 43from three.serialization import TO_JSON
 44from three.MF.V3.Buffer import Buffer
 45
 46
 47
 48
 49class Scanner:
 50    """
 51    Main class to manage and communicate with the Matter and Form THREE 3D Scanner via websocket.
 52
 53    Attributes:
 54        * OnTask (Optional[Callable[[Task], None]]): Callback for any task related messages, default is None. Will fire for task complete, progress, and error.
 55        * OnMessage (Optional[Callable[[str], None]]): Callback function to handle messages, default is None. Messages are any calls related to the system that are not tasks or buffers. Eg. {"Message":{"HasTurntable":true}}
 56        * OnBuffer (Optional[Callable[[Any, bytes], None]]): Callback Function to handle buffer data, default is None. Buffers can be image or scan data. These are binary formats that are sent separately from tasks. Buffers will contain a header that describes the buffer data size. Please note that websocket buffers are limited in size and need to be sent in chunks.
 57    """
 58    
 59    __bufferDescriptor = None
 60    __buffer = None
 61    __error = None
 62    __taskIndex:int = 0
 63    __tasks:List[Task] = []
 64
 65
 66    def __init__(self,
 67        OnTask: Optional[Callable[[Task], None]] = None,
 68        OnMessage: Optional[Callable[[str], None]] = None,
 69        OnBuffer: Optional[Callable[[Any, bytes], None]] = None,
 70        ):
 71        """
 72        Initializes the Scanner object.
 73
 74        Args:
 75            * OnTask (Optional[Callable[[Task], None]]): Callback for any task related messages, default is None. Will fire for task complete, progress, and error.
 76            * OnMessage (Optional[Callable[[str], None]]): Callback function to handle messages, default is None. Messages are any calls related to the system that are not tasks or buffers. Eg. {"Message":{"HasTurntable":true}}
 77            * OnBuffer (Optional[Callable[[Any, bytes], None]]): Callback Function to handle buffer data, default is None. Buffers can be image or scan data. These are binary formats that are sent separately from tasks. Buffers will contain a header that describes the buffer data size. Please note that websocket buffers are limited in size and need to be sent in chunks.
 78        """
 79        self.__isConnected = False
 80
 81        self.OnTask = OnTask
 82        self.OnMessage = OnMessage
 83        self.OnBuffer = OnBuffer
 84        
 85        self.__task_return_event = threading.Event()
 86        
 87        # Dynamically add methods from Three to Scanner
 88        # self._add_three_methods()
 89
 90    # def _add_three_methods(self):
 91    #     """
 92    #     Dynamically adds functions from the three_methods module to the Scanner class.
 93    #     """
 94    #     for name, func in inspect.getmembers(Three, predicate=inspect.isfunction):
 95    #         if not name.startswith('_'):
 96    #             setattr(self, name, func.__get__(self, self.__class__))
 97
 98
 99    def Connect(self, URI:str, timeoutSec=5) -> bool:
100        """
101        Attempts to connect to the scanner using the specified URI and timeout.
102
103        Args:
104            * URI (str): The URI of the websocket server.
105            * timeoutSec (int): Timeout in seconds, default is 5.
106
107        Returns:
108            bool: True if connection is successful, raises Exception otherwise.
109
110        Raises:
111            Exception: If connection fails within the timeout or due to an error.
112        """
113        print('Connecting to: ', URI)
114        self.__URI = URI
115        self.__isConnected = False
116        self.__error = None
117
118        self.__serverVersion__= None
119
120        self.websocket = websocket.WebSocketApp(self.__URI,
121                              on_open=self.__OnOpen,
122                              on_close=self.__OnClose,
123                              on_error=self.__OnError,
124                              on_message=self.__OnMessage,
125                              )
126        
127        wst = threading.Thread(target=self.websocket.run_forever)
128        wst.daemon = True
129        wst.start()
130
131        # Wait for connection
132        start = time.time()
133        while time.time() < start + timeoutSec:
134            if self.__isConnected:
135                # Not checking versions => return True
136                    return True
137            elif self.__error:
138                raise Exception(self.__error)
139            time.sleep(0.1)
140        
141        raise Exception('Connection timeout')
142        
143    def Disconnect(self) -> None:
144        """
145        Close the websocket connection.
146        """
147        if self.__isConnected:
148            # Close the connection
149            self.websocket.close()
150            # Wait for the connection to be closed.
151            while self.__isConnected:
152                time.sleep(0.1)
153
154    def IsConnected(self)-> bool:
155        """
156        Checks if the scanner is currently connected.
157
158        Returns:
159            bool: True if connected, False otherwise.
160        """
161        return self.__isConnected
162    
163    def __callback(self, callback, *args) -> None:
164        if callback:
165                callback(self, *args)
166
167    # Called when the connection is opened
168    def __OnOpen(self, ws) -> None:
169        """
170        Callback function for when the websocket connection is successfully opened.
171
172        Prints a success message to the console.
173
174        Args:
175            ws: The websocket object.
176        """
177        self.__isConnected = True
178        print('Connected to: ', self.__URI)
179
180    # Called when the connection is closed
181    def __OnClose(self, ws, close_status_code, close_msg):
182        """
183        Callback function for when the websocket connection is closed.
184
185        Prints a disconnect message to the console.
186
187        Args:
188            ws: The websocket object.
189            close_status_code: The code indicating why the websocket was closed.
190            close_msg: Additional message about why the websocket was closed.
191        """
192        if self.__isConnected:
193            print('Disconnected')
194        self.__isConnected = False
195
196    # Called when an error happens
197    def __OnError(self, ws, error) -> None:
198        """
199        Callback function for when an error occurs in the websocket connection.
200
201        Prints an error message to the console and stores the error for reference.
202
203        Args:
204            ws: The websocket object.
205            error: The error that occurred.
206        """
207        if self.__isConnected:
208            print('Error: ', error)    
209        else:
210            self.__error = error
211        
212    # Called when a message arrives on the connection
213    def __OnMessage(self, ws, message) -> None:
214        """
215        Callback function for handling messages received via the websocket.
216
217        Determines the type of message received (Task, Buffer, or general Message) and
218        triggers the corresponding handler function if one is set.
219
220        Args:
221            ws: The websocket object.
222            message: The raw message received, which can be either a byte string or a JSON string.
223        """
224        # Bytes ?
225        if isinstance(message, bytes):
226            if self.OnBuffer:
227                
228                if self.__buffer:
229                    self.__buffer += message
230                else:
231                    self.__buffer = message
232                if self.__bufferDescriptor.Size == len(self.__buffer):
233                    self.OnBuffer(self.__bufferDescriptor, message)
234                    self.__bufferDescriptor = None 
235                    self.__buffer = None
236        else:
237            obj = json.loads(message)              
238        
239            # Task
240            if 'Task' in obj:
241                # Create the task from the message
242                task = Task(**obj['Task'])
243                
244                if (task.Progress):
245                    # Extract the first (and only) item from the task.Progress dictionary
246                    # TODO Duct tape fix due to schema weirdness for progress
247                    key, process = next(iter(task.Progress.items()))
248                    task.Progress = type('Progress', (object,), {
249                        'current': process["current"],
250                        'step': process["step"],
251                        'total': process["total"]
252                    })()
253
254                # Find the original task for reference
255                inputTask = self.__FindTaskWithIndex(task.Index)
256                if inputTask == None:
257                    raise Exception('Task not found')
258                    
259                if task.Error:
260                    inputTask.Error = task.Error
261                    self.__OnError(self.websocket, task.Error)
262                    self.__task_return_event.set()
263                    
264                # If assigned => Call the handler
265                if self.OnTask:
266                    self.OnTask(task)
267                
268                
269                # If waiting for a response, set the response and notify
270                if (task.State == TaskState.Completed.value):
271                    if task.Output:
272                        inputTask.Output = task.Output
273                    self.__task_return_event.set()
274                elif (task.State == TaskState.Failed.value):
275                    inputTask.Error = task.Error
276                    self.__task_return_event
277                    
278            # Buffer
279            elif 'Buffer' in obj:
280                self.__bufferDescriptor = Buffer(**obj['Buffer'])
281                self.__buffer = None    
282            # Message
283            elif 'Message' in obj:
284                if self.OnMessage:
285                    self.OnMessage(obj)
286
287    def SendTask(self, task, buffer:bytes = None) -> Any:
288        """
289        Sends a task to the scanner.
290        Tasks are general control requests for the scanner. (eg. Camera exposure, or Get Image)
291
292        Creates a task, serializes it, and sends it via the websocket.
293
294        Args:
295            * task (Task): The task to send.
296            * buffer (bytes): The buffer data to send, default is None.
297
298        Returns:
299            Any: The task object that was sent.
300
301        Raises:
302            AssertionError: If the connection is not established.
303        """
304        assert self.__isConnected
305
306        # Update the index
307        task.Index = self.__taskIndex
308        task.Input.Index = self.__taskIndex
309        self.__taskIndex += 1
310
311        # Send the task
312        self.__task_return_event.clear()
313        
314        # Append the task
315        self.__tasks.append(task)
316
317        if buffer == None:
318            self.__SendTask(task)
319        else:
320            self.__SendTaskWithBuffer(task, buffer)
321
322        if task.Output:
323            # Wait for response
324            self.__task_return_event.wait()
325
326        self.__tasks.remove(task)
327
328        return task
329    
330    # Send a task to the scanner
331    def __SendTask(self, task):
332        assert self.__isConnected
333
334        # Serialize the task
335        message = TO_JSON(task.Input)
336        
337        # Build and send the message
338        message = '{"Task":' + message + '}'
339        print('Message: ', message)
340
341        self.websocket.send(message)
342
343    # Send a task with its buffer to the scanner
344    def __SendTaskWithBuffer(self, task:Task, buffer:bytes):
345        assert self.__isConnected
346
347        # Send the task
348        self.__SendTask(task)
349
350        # Build the buffer descriptor
351        bufferSize = len(buffer)
352        bufferDescriptor = Buffer(0, bufferSize, task)
353
354        # Serialize the buffer descriptor
355        bufferMessage = TO_JSON(bufferDescriptor)
356
357        # Send the buffer descriptor
358        bufferMessage = '{"Buffer":' + bufferMessage + '}'
359        self.websocket.send(bufferMessage)
360
361        # The maximum websocket payload size is 32 MB.
362        MAX_SIZE = 32000000
363        sentSize = 0
364
365        # Send all the sub-payloads of the maximum payload size.
366        while sentSize + MAX_SIZE < bufferSize:
367            self.websocket.send(buffer[sentSize:sentSize + MAX_SIZE], websocket.ABNF.OPCODE_BINARY)
368            sentSize += MAX_SIZE
369
370        # Send the remaining data.
371        if sentSize < bufferSize:
372            self.websocket.send(buffer[sentSize:bufferSize], websocket.ABNF.OPCODE_BINARY)
373    
374    def __FindTaskWithIndex(self, index:int) -> Task:
375        # Find the task in the list
376        for i, t in enumerate(self.__tasks):
377            if t.Index == index:
378                return t
379                break
380        return None
381
382    # Dynamically bound functions from three.py
383
384    def add_merge_to_project(self) -> 'Task':
385        """Add a merged scan to the current project."""
386        return Three.add_merge_to_project(self)
387
388    def align(self, source: 'int', target: 'int', rough: 'Align.Rough' = None, fine: 'Align.Fine' = None) -> 'Task':
389        """Align two scan groups."""
390        return Three.align(self, source, target, rough, fine)
391
392    def auto_focus(self, applyAll: 'bool', cameras: 'list[AutoFocus.Camera]' = None) -> 'Task':
393        """Auto focus one or both cameras."""
394        return Three.auto_focus(self, applyAll, cameras)
395
396    def bounding_box(self, selection: 'ScanSelection', axisAligned: 'bool') -> 'Task':
397        """Get the bounding box of a set of scan groups."""
398        return Three.bounding_box(self, selection, axisAligned)
399
400    def calibrate_cameras(self) -> 'Task':
401        """Calibrate the cameras."""
402        return Three.calibrate_cameras(self)
403
404    def calibrate_turntable(self) -> 'Task':
405        """Calibrate the turntable."""
406        return Three.calibrate_turntable(self)
407
408    def calibration_capture_targets(self) -> 'Task':
409        """Get the calibration capture target for each camera calibration capture."""
410        return Three.calibration_capture_targets(self)
411
412    def camera_calibration(self) -> 'Task':
413        """Get the camera calibration descriptor."""
414        return Three.camera_calibration(self)
415
416    def capture_image(self, selection: 'list[int]' = None, codec: 'CaptureImage.Codec' = None, grayscale: 'bool' = None) -> 'Task':
417        """Capture a single Image."""
418        return Three.capture_image(self, selection, codec, grayscale)
419
420    def clear_settings(self) -> 'Task':
421        """Clear scanner settings and restore the default values."""
422        return Three.clear_settings(self)
423
424    def close_project(self) -> 'Task':
425        """Close the current open project."""
426        return Three.close_project(self)
427
428    def connect_wifi(self, ssid: 'str', password: 'str') -> 'Task':
429        """Connect to a wifi network."""
430        return Three.connect_wifi(self, ssid, password)
431
432    def copy_groups(self, sourceIndexes: 'list[int]' = None, targetIndex: 'int' = None, childPosition: 'int' = None, nameSuffix: 'str' = None, enumerate: 'bool' = None) -> 'Task':
433        """Copy a set of scan groups in the current open project."""
434        return Three.copy_groups(self, sourceIndexes, targetIndex, childPosition, nameSuffix, enumerate)
435
436    def depth_map(self, camera: 'Camera' = None, projector: 'Projector' = None, turntable: 'Turntable' = None, capture: 'Capture' = None, processing: 'Scan.Processing' = None, alignWithScanner: 'bool' = None, centerAtOrigin: 'bool' = None) -> 'Task':
437        """Capture a depth map."""
438        return Three.depth_map(self, camera, projector, turntable, capture, processing, alignWithScanner, centerAtOrigin)
439
440    def detect_calibration_card(self, Input: 'int') -> 'Task':
441        """Detect the calibration card on one or both cameras."""
442        return Three.detect_calibration_card(self, Input)
443
444    def download_project(self, Input: 'int') -> 'Task':
445        """Download a project from the scanner."""
446        return Three.download_project(self, Input)
447
448    def export(self, selection: 'ScanSelection' = None, texture: 'bool' = None, merge: 'bool' = None, format: 'Export.Format' = None, scale: 'float' = None, color: 'Export.Color' = None) -> 'Task':
449        """Export a group of scans."""
450        return Three.export(self, selection, texture, merge, format, scale, color)
451
452    def export_factory_calibration_logs(self) -> 'Task':
453        """Export factory calibration logs."""
454        return Three.export_factory_calibration_logs(self)
455
456    def export_heat_map(self, selection: 'ScanSelection' = None, texture: 'bool' = None, merge: 'bool' = None, format: 'Export.Format' = None, scale: 'float' = None, color: 'Export.Color' = None) -> 'Task':
457        """Export a mesh with vertex colors generated by the 'HeatMap' task."""
458        return Three.export_heat_map(self, selection, texture, merge, format, scale, color)
459
460    def export_logs(self, Input: 'bool' = None) -> 'Task':
461        """Export scanner logs."""
462        return Three.export_logs(self, Input)
463
464    def export_merge(self, selection: 'ScanSelection' = None, texture: 'bool' = None, merge: 'bool' = None, format: 'Export.Format' = None, scale: 'float' = None, color: 'Export.Color' = None) -> 'Task':
465        """Export a merged scan."""
466        return Three.export_merge(self, selection, texture, merge, format, scale, color)
467
468    def factory_reset(self) -> 'Task':
469        """Reset the scanner to factory settings."""
470        return Three.factory_reset(self)
471
472    def flatten_group(self, Input: 'int') -> 'Task':
473        """Flatten a scan group such that it only consists of single scans."""
474        return Three.flatten_group(self, Input)
475
476    def forget_wifi(self) -> 'Task':
477        """Forget all wifi connections."""
478        return Three.forget_wifi(self)
479
480    def has_cameras(self) -> 'Task':
481        """Check if the scanner has working cameras."""
482        return Three.has_cameras(self)
483
484    def has_projector(self) -> 'Task':
485        """Check if the scanner has a working projector."""
486        return Three.has_projector(self)
487
488    def has_turntable(self) -> 'Task':
489        """Check if the scanner is connected to a working turntable."""
490        return Three.has_turntable(self)
491
492    def heat_map(self, sources: 'list[int]' = None, targets: 'list[int]' = None, outlierDistance: 'float' = None) -> 'Task':
493        """Compute the point-to-mesh distances of a source mesh to a target mesh and visualize as a heat map."""
494        return Three.heat_map(self, sources, targets, outlierDistance)
495
496    def import_file(self, name: 'str' = None, scale: 'float' = None, unit: 'Import.Unit' = None, center: 'bool' = None, groupIndex: 'int' = None) -> 'Task':
497        """Import a set of 3D meshes to the current open project.  The meshes must be archived in a ZIP file."""
498        return Three.import_file(self, name, scale, unit, center, groupIndex)
499
500    def list_export_formats(self) -> 'Task':
501        """List all export formats."""
502        return Three.list_export_formats(self)
503
504    def list_groups(self) -> 'Task':
505        """List the scan groups in the current open project."""
506        return Three.list_groups(self)
507
508    def list_network_interfaces(self) -> 'Task':
509        """List available wifi networks."""
510        return Three.list_network_interfaces(self)
511
512    def list_projects(self) -> 'Task':
513        """List all projects."""
514        return Three.list_projects(self)
515
516    def list_scans(self) -> 'Task':
517        """List the scans in the current open project."""
518        return Three.list_scans(self)
519
520    def list_settings(self) -> 'Task':
521        """Get scanner settings."""
522        return Three.list_settings(self)
523
524    def list_wifi(self) -> 'Task':
525        """List available wifi networks."""
526        return Three.list_wifi(self)
527
528    def merge(self, selection: 'ScanSelection' = None, remesh: 'Merge.Remesh' = None, simplify: 'Merge.Simplify' = None, texturize: 'bool' = None) -> 'Task':
529        """Merge two or more scan groups."""
530        return Three.merge(self, selection, remesh, simplify, texturize)
531
532    def merge_data(self, index: 'int', mergeStep: 'ScanData.MergeStep' = None, buffers: 'list[ScanData.Buffer]' = None, metadata: 'list[ScanData.Metadata]' = None) -> 'Task':
533        """Download the raw scan data for the current merge process."""
534        return Three.merge_data(self, index, mergeStep, buffers, metadata)
535
536    def move_group(self, Input: 'list[int]' = None) -> 'Task':
537        """Move a scan group."""
538        return Three.move_group(self, Input)
539
540    def new_group(self, parentIndex: 'int' = None, baseName: 'str' = None, color: 'list[float]' = None, visible: 'bool' = None, collapsed: 'bool' = None, rotation: 'list[float]' = None, translation: 'list[float]' = None) -> 'Task':
541        """Create a new scan group."""
542        return Three.new_group(self, parentIndex, baseName, color, visible, collapsed, rotation, translation)
543
544    def new_project(self, Input: 'str' = None) -> 'Task':
545        """Create a new project."""
546        return Three.new_project(self, Input)
547
548    def new_scan(self, camera: 'Camera' = None, projector: 'Projector' = None, turntable: 'Turntable' = None, capture: 'Capture' = None, processing: 'Scan.Processing' = None, alignWithScanner: 'bool' = None, centerAtOrigin: 'bool' = None) -> 'Task':
549        """Capture a new scan."""
550        return Three.new_scan(self, camera, projector, turntable, capture, processing, alignWithScanner, centerAtOrigin)
551
552    def open_project(self, Input: 'int') -> 'Task':
553        """Open an existing project."""
554        return Three.open_project(self, Input)
555
556    def pop_settings(self, Input: 'bool' = None) -> 'Task':
557        """Pop and restore scanner settings from the settings stack."""
558        return Three.pop_settings(self, Input)
559
560    def push_settings(self) -> 'Task':
561        """Push the current scanner settings to the settings stack."""
562        return Three.push_settings(self)
563
564    def reboot(self) -> 'Task':
565        """Reboot the scanner."""
566        return Three.reboot(self)
567
568    def remove_groups(self, Input: 'list[int]' = None) -> 'Task':
569        """Remove selected scan groups."""
570        return Three.remove_groups(self, Input)
571
572    def remove_projects(self, Input: 'list[int]' = None) -> 'Task':
573        """Remove selected projects."""
574        return Three.remove_projects(self, Input)
575
576    def restore_factory_calibration(self) -> 'Task':
577        """Restore factory calibration."""
578        return Three.restore_factory_calibration(self)
579
580    def rotate_turntable(self, Input: 'int') -> 'Task':
581        """Rotate the turntable."""
582        return Three.rotate_turntable(self, Input)
583
584    def scan_data(self, index: 'int', mergeStep: 'ScanData.MergeStep' = None, buffers: 'list[ScanData.Buffer]' = None, metadata: 'list[ScanData.Metadata]' = None) -> 'Task':
585        """Download the raw scan data for a scan in the current open project."""
586        return Three.scan_data(self, index, mergeStep, buffers, metadata)
587
588    def set_cameras(self, selection: 'list[int]' = None, autoExposure: 'bool' = None, exposure: 'int' = None, analogGain: 'float' = None, digitalGain: 'int' = None, focus: 'int' = None) -> 'Task':
589        """Apply camera settings to one or both cameras."""
590        return Three.set_cameras(self, selection, autoExposure, exposure, analogGain, digitalGain, focus)
591
592    def set_group(self, index: 'int', name: 'str' = None, color: 'list[float]' = None, visible: 'bool' = None, collapsed: 'bool' = None, rotation: 'list[float]' = None, translation: 'list[float]' = None) -> 'Task':
593        """Set scan group properties."""
594        return Three.set_group(self, index, name, color, visible, collapsed, rotation, translation)
595
596    def set_project(self, index: 'int' = None, name: 'str' = None) -> 'Task':
597        """Apply settings to the current open project."""
598        return Three.set_project(self, index, name)
599
600    def set_projector(self, on: 'bool' = None, brightness: 'float' = None, pattern: 'Projector.Pattern' = None, image: 'Projector.Image' = None, color: 'list[float]' = None, buffer: 'bytes' = None) -> 'Task':
601        """Apply projector settings."""
602        return Three.set_projector(self, on, brightness, pattern, image, color, buffer)
603
604    def shutdown(self) -> 'Task':
605        """Shutdown the scanner."""
606        return Three.shutdown(self)
607
608    def smooth(self, selection: 'ScanSelection' = None, taubin: 'Smooth.Taubin' = None) -> 'Task':
609        """Smooth a set of scans."""
610        return Three.smooth(self, selection, taubin)
611
612    def split_group(self, Input: 'int') -> 'Task':
613        """Split a scan group (ie. move its subgroups to its parent group)."""
614        return Three.split_group(self, Input)
615
616    def start_video(self) -> 'Task':
617        """Start the video stream."""
618        return Three.start_video(self)
619
620    def stop_video(self) -> 'Task':
621        """Stop the video stream."""
622        return Three.stop_video(self)
623
624    def system_info(self, updateMajor: 'bool' = None, updateNightly: 'bool' = None) -> 'Task':
625        """Get system information."""
626        return Three.system_info(self, updateMajor, updateNightly)
627
628    def transform_group(self, index: 'int', name: 'str' = None, color: 'list[float]' = None, visible: 'bool' = None, collapsed: 'bool' = None, rotation: 'list[float]' = None, translation: 'list[float]' = None) -> 'Task':
629        """Apply a rigid transformation to a group."""
630        return Three.transform_group(self, index, name, color, visible, collapsed, rotation, translation)
631
632    def turntable_calibration(self) -> 'Task':
633        """Get the turntable calibration descriptor."""
634        return Three.turntable_calibration(self)
635
636    def update_settings(self, advanced: 'Advanced' = None, camera: 'Camera' = None, capture: 'Capture' = None, i18n: 'I18n' = None, projector: 'Projector' = None, style: 'Style' = None, turntable: 'Turntable' = None, tutorials: 'Tutorials' = None, viewer: 'Viewer' = None, software: 'Software' = None) -> 'Task':
637        """Update scanner settings."""
638        return Three.update_settings(self, advanced, camera, capture, i18n, projector, style, turntable, tutorials, viewer, software)
639
640    def upload_project(self, buffer: 'bytes') -> 'Task':
641        """Upload a project to the scanner."""
642        return Three.upload_project(self, buffer)