three.MF.V3.Three

   1from MF.V3 import Task
   2from MF.V3.Settings.Advanced import Advanced as MF_V3_Settings_Advanced_Advanced
   3from MF.V3.Settings.Align import Align as MF_V3_Settings_Align_Align
   4from MF.V3.Settings.AutoFocus import AutoFocus as MF_V3_Settings_AutoFocus_AutoFocus
   5from MF.V3.Settings.BoundingBox import BoundingBox as MF_V3_Settings_BoundingBox_BoundingBox
   6from MF.V3.Settings.Camera import Camera as MF_V3_Settings_Camera_Camera
   7from MF.V3.Settings.Capture import Capture as MF_V3_Settings_Capture_Capture
   8from MF.V3.Settings.CaptureImage import CaptureImage as MF_V3_Settings_CaptureImage_CaptureImage
   9from MF.V3.Settings.CopyGroups import CopyGroups as MF_V3_Settings_CopyGroups_CopyGroups
  10from MF.V3.Settings.Export import Export as MF_V3_Settings_Export_Export
  11from MF.V3.Settings.Group import Group as MF_V3_Settings_Group_Group
  12from MF.V3.Settings.HeatMap import HeatMap as MF_V3_Settings_HeatMap_HeatMap
  13from MF.V3.Settings.I18n import I18n as MF_V3_Settings_I18n_I18n
  14from MF.V3.Settings.Import import Import as MF_V3_Settings_Import_Import
  15from MF.V3.Settings.Merge import Merge as MF_V3_Settings_Merge_Merge
  16from MF.V3.Settings.NewGroup import NewGroup as MF_V3_Settings_NewGroup_NewGroup
  17from MF.V3.Settings.Project import Project as MF_V3_Settings_Project_Project
  18from MF.V3.Settings.Projector import Projector as MF_V3_Settings_Projector_Projector
  19from MF.V3.Settings.Scan import Scan as MF_V3_Settings_Scan_Scan
  20from MF.V3.Settings.ScanData import ScanData as MF_V3_Settings_ScanData_ScanData
  21from MF.V3.Settings.ScanSelection import ScanSelection as MF_V3_Settings_ScanSelection_ScanSelection
  22from MF.V3.Settings.Scanner import Scanner as MF_V3_Settings_Scanner_Scanner
  23from MF.V3.Settings.Software import Software as MF_V3_Settings_Software_Software
  24from MF.V3.Settings.Style import Style as MF_V3_Settings_Style_Style
  25from MF.V3.Settings.Turntable import Turntable as MF_V3_Settings_Turntable_Turntable
  26from MF.V3.Settings.Tutorials import Tutorials as MF_V3_Settings_Tutorials_Tutorials
  27from MF.V3.Settings.Viewer import Viewer as MF_V3_Settings_Viewer_Viewer
  28from MF.V3.Settings.Wifi import Wifi as MF_V3_Settings_Wifi_Wifi
  29from MF.V3.Tasks.AddMergeToProject import AddMergeToProject as MF_V3_Tasks_AddMergeToProject
  30from MF.V3.Tasks.Align import Align as MF_V3_Tasks_Align
  31from MF.V3.Tasks.AutoFocus import AutoFocus as MF_V3_Tasks_AutoFocus
  32from MF.V3.Tasks.BoundingBox import BoundingBox as MF_V3_Tasks_BoundingBox
  33from MF.V3.Tasks.CalibrateCameras import CalibrateCameras as MF_V3_Tasks_CalibrateCameras
  34from MF.V3.Tasks.CalibrateTurntable import CalibrateTurntable as MF_V3_Tasks_CalibrateTurntable
  35from MF.V3.Tasks.CalibrationCaptureTargets import CalibrationCaptureTargets as MF_V3_Tasks_CalibrationCaptureTargets
  36from MF.V3.Tasks.CameraCalibration import CameraCalibration as MF_V3_Tasks_CameraCalibration
  37from MF.V3.Tasks.CaptureImage import CaptureImage as MF_V3_Tasks_CaptureImage
  38from MF.V3.Tasks.CloseProject import CloseProject as MF_V3_Tasks_CloseProject
  39from MF.V3.Tasks.ConnectWifi import ConnectWifi as MF_V3_Tasks_ConnectWifi
  40from MF.V3.Tasks.CopyGroups import CopyGroups as MF_V3_Tasks_CopyGroups
  41from MF.V3.Tasks.DepthMap import DepthMap as MF_V3_Tasks_DepthMap
  42from MF.V3.Tasks.DetectCalibrationCard import DetectCalibrationCard as MF_V3_Tasks_DetectCalibrationCard
  43from MF.V3.Tasks.DownloadProject import DownloadProject as MF_V3_Tasks_DownloadProject
  44from MF.V3.Tasks.Export import Export as MF_V3_Tasks_Export
  45from MF.V3.Tasks.ExportHeatMap import ExportHeatMap as MF_V3_Tasks_ExportHeatMap
  46from MF.V3.Tasks.ExportLogs import ExportLogs as MF_V3_Tasks_ExportLogs
  47from MF.V3.Tasks.ExportMerge import ExportMerge as MF_V3_Tasks_ExportMerge
  48from MF.V3.Tasks.FlattenGroup import FlattenGroup as MF_V3_Tasks_FlattenGroup
  49from MF.V3.Tasks.ForgetWifi import ForgetWifi as MF_V3_Tasks_ForgetWifi
  50from MF.V3.Tasks.HasCameras import HasCameras as MF_V3_Tasks_HasCameras
  51from MF.V3.Tasks.HasProjector import HasProjector as MF_V3_Tasks_HasProjector
  52from MF.V3.Tasks.HasTurntable import HasTurntable as MF_V3_Tasks_HasTurntable
  53from MF.V3.Tasks.HeatMap import HeatMap as MF_V3_Tasks_HeatMap
  54from MF.V3.Tasks.Import import Import as MF_V3_Tasks_Import
  55from MF.V3.Tasks.ListExportFormats import ListExportFormats as MF_V3_Tasks_ListExportFormats
  56from MF.V3.Tasks.ListGroups import ListGroups as MF_V3_Tasks_ListGroups
  57from MF.V3.Tasks.ListNetworkInterfaces import ListNetworkInterfaces as MF_V3_Tasks_ListNetworkInterfaces
  58from MF.V3.Tasks.ListProjects import ListProjects as MF_V3_Tasks_ListProjects
  59from MF.V3.Tasks.ListScans import ListScans as MF_V3_Tasks_ListScans
  60from MF.V3.Tasks.ListSettings import ListSettings as MF_V3_Tasks_ListSettings
  61from MF.V3.Tasks.ListWifi import ListWifi as MF_V3_Tasks_ListWifi
  62from MF.V3.Tasks.Merge import Merge as MF_V3_Tasks_Merge
  63from MF.V3.Tasks.MergeData import MergeData as MF_V3_Tasks_MergeData
  64from MF.V3.Tasks.MoveGroup import MoveGroup as MF_V3_Tasks_MoveGroup
  65from MF.V3.Tasks.NewGroup import NewGroup as MF_V3_Tasks_NewGroup
  66from MF.V3.Tasks.NewProject import NewProject as MF_V3_Tasks_NewProject
  67from MF.V3.Tasks.NewScan import NewScan as MF_V3_Tasks_NewScan
  68from MF.V3.Tasks.OpenProject import OpenProject as MF_V3_Tasks_OpenProject
  69from MF.V3.Tasks.PopSettings import PopSettings as MF_V3_Tasks_PopSettings
  70from MF.V3.Tasks.PushSettings import PushSettings as MF_V3_Tasks_PushSettings
  71from MF.V3.Tasks.Reboot import Reboot as MF_V3_Tasks_Reboot
  72from MF.V3.Tasks.RemoveGroups import RemoveGroups as MF_V3_Tasks_RemoveGroups
  73from MF.V3.Tasks.RemoveProjects import RemoveProjects as MF_V3_Tasks_RemoveProjects
  74from MF.V3.Tasks.RestoreFactoryCalibration import RestoreFactoryCalibration as MF_V3_Tasks_RestoreFactoryCalibration
  75from MF.V3.Tasks.RotateTurntable import RotateTurntable as MF_V3_Tasks_RotateTurntable
  76from MF.V3.Tasks.ScanData import ScanData as MF_V3_Tasks_ScanData
  77from MF.V3.Tasks.SetCameras import SetCameras as MF_V3_Tasks_SetCameras
  78from MF.V3.Tasks.SetGroup import SetGroup as MF_V3_Tasks_SetGroup
  79from MF.V3.Tasks.SetProject import SetProject as MF_V3_Tasks_SetProject
  80from MF.V3.Tasks.SetProjector import SetProjector as MF_V3_Tasks_SetProjector
  81from MF.V3.Tasks.Shutdown import Shutdown as MF_V3_Tasks_Shutdown
  82from MF.V3.Tasks.SplitGroup import SplitGroup as MF_V3_Tasks_SplitGroup
  83from MF.V3.Tasks.StartVideo import StartVideo as MF_V3_Tasks_StartVideo
  84from MF.V3.Tasks.StopVideo import StopVideo as MF_V3_Tasks_StopVideo
  85from MF.V3.Tasks.SystemInfo import SystemInfo as MF_V3_Tasks_SystemInfo
  86from MF.V3.Tasks.TransformGroup import TransformGroup as MF_V3_Tasks_TransformGroup
  87from MF.V3.Tasks.TurntableCalibration import TurntableCalibration as MF_V3_Tasks_TurntableCalibration
  88from MF.V3.Tasks.UpdateSettings import UpdateSettings as MF_V3_Tasks_UpdateSettings
  89from MF.V3.Tasks.UploadProject import UploadProject as MF_V3_Tasks_UploadProject
  90from typing import List
  91
  92
  93def list_network_interfaces(self) -> Task:
  94
  95    """
  96     List available wifi networks.
  97    """
  98    list_network_interfaces_request = MF_V3_Tasks_ListNetworkInterfaces.Request(
  99        Index=0,
 100        Type="ListNetworkInterfaces"
 101    )
 102    list_network_interfaces_response = MF_V3_Tasks_ListNetworkInterfaces.Response(
 103        Index=0,
 104        Type="ListNetworkInterfaces"
 105    )
 106    task = Task(Index=0, Type="ListNetworkInterfaces", Input=list_network_interfaces_request, Output=list_network_interfaces_response)
 107    self.SendTask(task)
 108    return task
 109
 110
 111def list_wifi(self) -> Task:
 112
 113    """
 114     List available wifi networks.
 115    """
 116    list_wifi_request = MF_V3_Tasks_ListWifi.Request(
 117        Index=0,
 118        Type="ListWifi"
 119    )
 120    list_wifi_response = MF_V3_Tasks_ListWifi.Response(
 121        Index=0,
 122        Type="ListWifi"
 123    )
 124    task = Task(Index=0, Type="ListWifi", Input=list_wifi_request, Output=list_wifi_response)
 125    self.SendTask(task)
 126    return task
 127
 128
 129def connect_wifi(self, ssid: str, password: str) -> Task:
 130
 131    """
 132     Connect to a wifi network.
 133    """
 134    connect_wifi_request = MF_V3_Tasks_ConnectWifi.Request(
 135        Index=0,
 136        Type="ConnectWifi",
 137        Input=MF_V3_Settings_Wifi_Wifi(
 138            ssid=ssid,
 139            password=password,
 140        )
 141    )
 142    connect_wifi_response = MF_V3_Tasks_ConnectWifi.Response(
 143        Index=0,
 144        Type="ConnectWifi",
 145        Input=MF_V3_Settings_Wifi_Wifi(
 146            ssid=ssid,
 147            password=password,
 148        )
 149    )
 150    task = Task(Index=0, Type="ConnectWifi", Input=connect_wifi_request, Output=connect_wifi_response)
 151    self.SendTask(task)
 152    return task
 153
 154
 155def forget_wifi(self) -> Task:
 156
 157    """
 158     Forget all wifi connections.
 159    """
 160    forget_wifi_request = MF_V3_Tasks_ForgetWifi.Request(
 161        Index=0,
 162        Type="ForgetWifi"
 163    )
 164    forget_wifi_response = MF_V3_Tasks_ForgetWifi.Response(
 165        Index=0,
 166        Type="ForgetWifi"
 167    )
 168    task = Task(Index=0, Type="ForgetWifi", Input=forget_wifi_request, Output=forget_wifi_response)
 169    self.SendTask(task)
 170    return task
 171
 172
 173def list_settings(self) -> Task:
 174
 175    """
 176     Get scanner settings.
 177    """
 178    list_settings_request = MF_V3_Tasks_ListSettings.Request(
 179        Index=0,
 180        Type="ListSettings"
 181    )
 182    list_settings_response = MF_V3_Tasks_ListSettings.Response(
 183        Index=0,
 184        Type="ListSettings"
 185    )
 186    task = Task(Index=0, Type="ListSettings", Input=list_settings_request, Output=list_settings_response)
 187    self.SendTask(task)
 188    return task
 189
 190
 191def push_settings(self) -> Task:
 192
 193    """
 194     Push the current scanner settings to the settings stack.
 195    """
 196    push_settings_request = MF_V3_Tasks_PushSettings.Request(
 197        Index=0,
 198        Type="PushSettings"
 199    )
 200    push_settings_response = MF_V3_Tasks_PushSettings.Response(
 201        Index=0,
 202        Type="PushSettings"
 203    )
 204    task = Task(Index=0, Type="PushSettings", Input=push_settings_request, Output=push_settings_response)
 205    self.SendTask(task)
 206    return task
 207
 208
 209def pop_settings(self, Input: bool = None) -> Task:
 210
 211    """
 212      Pop and restore scanner settings from the settings stack.
 213    """
 214    pop_settings_request = MF_V3_Tasks_PopSettings.Request(
 215        Index=0,
 216        Type="PopSettings",
 217        Input=Input
 218    )
 219    pop_settings_response = MF_V3_Tasks_PopSettings.Response(
 220        Index=0,
 221        Type="PopSettings"
 222    )
 223    task = Task(Index=0, Type="PopSettings", Input=pop_settings_request, Output=pop_settings_response)
 224    self.SendTask(task)
 225    return task
 226
 227
 228def update_settings(self, advanced: MF_V3_Settings_Advanced_Advanced = None, camera: MF_V3_Settings_Camera_Camera = None, capture: MF_V3_Settings_Capture_Capture = None, i18n: MF_V3_Settings_I18n_I18n = None, projector: MF_V3_Settings_Projector_Projector = None, style: MF_V3_Settings_Style_Style = None, turntable: MF_V3_Settings_Turntable_Turntable = None, tutorials: MF_V3_Settings_Tutorials_Tutorials = None, viewer: MF_V3_Settings_Viewer_Viewer = None, software: MF_V3_Settings_Software_Software = None) -> Task:
 229
 230    """
 231     Update scanner settings.
 232    """
 233    update_settings_request = MF_V3_Tasks_UpdateSettings.Request(
 234        Index=0,
 235        Type="UpdateSettings",
 236        Input=MF_V3_Settings_Scanner_Scanner(
 237            advanced=advanced,
 238            camera=camera,
 239            capture=capture,
 240            i18n=i18n,
 241            projector=projector,
 242            style=style,
 243            turntable=turntable,
 244            tutorials=tutorials,
 245            viewer=viewer,
 246            software=software,
 247        )
 248    )
 249    update_settings_response = MF_V3_Tasks_UpdateSettings.Response(
 250        Index=0,
 251        Type="UpdateSettings",
 252        Input=MF_V3_Settings_Scanner_Scanner(
 253            advanced=advanced,
 254            camera=camera,
 255            capture=capture,
 256            i18n=i18n,
 257            projector=projector,
 258            style=style,
 259            turntable=turntable,
 260            tutorials=tutorials,
 261            viewer=viewer,
 262            software=software,
 263        )
 264    )
 265    task = Task(Index=0, Type="UpdateSettings", Input=update_settings_request, Output=update_settings_response)
 266    self.SendTask(task)
 267    return task
 268
 269
 270def list_projects(self) -> Task:
 271
 272    """
 273     List all projects.
 274    """
 275    list_projects_request = MF_V3_Tasks_ListProjects.Request(
 276        Index=0,
 277        Type="ListProjects"
 278    )
 279    list_projects_response = MF_V3_Tasks_ListProjects.Response(
 280        Index=0,
 281        Type="ListProjects"
 282    )
 283    task = Task(Index=0, Type="ListProjects", Input=list_projects_request, Output=list_projects_response)
 284    self.SendTask(task)
 285    return task
 286
 287
 288def download_project(self, Input: int) -> Task:
 289
 290    """
 291     Download a project from the scanner.
 292    """
 293    download_project_request = MF_V3_Tasks_DownloadProject.Request(
 294        Index=0,
 295        Type="DownloadProject",
 296        Input=Input
 297    )
 298    download_project_response = MF_V3_Tasks_DownloadProject.Response(
 299        Index=0,
 300        Type="DownloadProject",
 301        Input=Input
 302    )
 303    task = Task(Index=0, Type="DownloadProject", Input=download_project_request, Output=download_project_response)
 304    self.SendTask(task)
 305    return task
 306
 307
 308def upload_project(self, buffer: bytes) -> Task:
 309
 310    """
 311     Upload a project to the scanner.
 312    """
 313    upload_project_request = MF_V3_Tasks_UploadProject.Request(
 314        Index=0,
 315        Type="UploadProject"
 316    )
 317    upload_project_response = MF_V3_Tasks_UploadProject.Response(
 318        Index=0,
 319        Type="UploadProject"
 320    )
 321    task = Task(Index=0, Type="UploadProject", Input=upload_project_request, Output=upload_project_response)
 322    self.SendTask(task, buffer)
 323    return task
 324
 325
 326def new_project(self, Input: str = None) -> Task:
 327
 328    """
 329     Create a new project.
 330    """
 331    new_project_request = MF_V3_Tasks_NewProject.Request(
 332        Index=0,
 333        Type="NewProject",
 334        Input=Input
 335    )
 336    new_project_response = MF_V3_Tasks_NewProject.Response(
 337        Index=0,
 338        Type="NewProject"
 339    )
 340    task = Task(Index=0, Type="NewProject", Input=new_project_request, Output=new_project_response)
 341    self.SendTask(task)
 342    return task
 343
 344
 345def open_project(self, Input: int) -> Task:
 346
 347    """
 348     Open an existing project.
 349    """
 350    open_project_request = MF_V3_Tasks_OpenProject.Request(
 351        Index=0,
 352        Type="OpenProject",
 353        Input=Input
 354    )
 355    open_project_response = MF_V3_Tasks_OpenProject.Response(
 356        Index=0,
 357        Type="OpenProject",
 358        Input=Input
 359    )
 360    task = Task(Index=0, Type="OpenProject", Input=open_project_request, Output=open_project_response)
 361    self.SendTask(task)
 362    return task
 363
 364
 365def close_project(self) -> Task:
 366
 367    """
 368     Close the current open project.
 369    """
 370    close_project_request = MF_V3_Tasks_CloseProject.Request(
 371        Index=0,
 372        Type="CloseProject"
 373    )
 374    close_project_response = MF_V3_Tasks_CloseProject.Response(
 375        Index=0,
 376        Type="CloseProject"
 377    )
 378    task = Task(Index=0, Type="CloseProject", Input=close_project_request, Output=close_project_response)
 379    self.SendTask(task)
 380    return task
 381
 382
 383def copy_groups(self, sourceIndexes: List[int] = None, targetIndex: int = None, childPosition: int = None, nameSuffix: str = None, enumerate: bool = None) -> Task:
 384
 385    """
 386     Copy a set of scan groups in the current open project.
 387    """
 388    copy_groups_request = MF_V3_Tasks_CopyGroups.Request(
 389        Index=0,
 390        Type="CopyGroups",
 391        Input=MF_V3_Settings_CopyGroups_CopyGroups(
 392            sourceIndexes=sourceIndexes,
 393            targetIndex=targetIndex,
 394            childPosition=childPosition,
 395            nameSuffix=nameSuffix,
 396            enumerate=enumerate,
 397        )
 398    )
 399    copy_groups_response = MF_V3_Tasks_CopyGroups.Response(
 400        Index=0,
 401        Type="CopyGroups",
 402        Input=MF_V3_Settings_CopyGroups_CopyGroups(
 403            sourceIndexes=sourceIndexes,
 404            targetIndex=targetIndex,
 405            childPosition=childPosition,
 406            nameSuffix=nameSuffix,
 407            enumerate=enumerate,
 408        ),
 409        Output=None
 410    )
 411    task = Task(Index=0, Type="CopyGroups", Input=copy_groups_request, Output=copy_groups_response)
 412    self.SendTask(task)
 413    return task
 414
 415
 416def remove_projects(self, Input: List[int] = None) -> Task:
 417
 418    """
 419     Remove selected projects.
 420    """
 421    remove_projects_request = MF_V3_Tasks_RemoveProjects.Request(
 422        Index=0,
 423        Type="RemoveProjects",
 424        Input=Input
 425    )
 426    remove_projects_response = MF_V3_Tasks_RemoveProjects.Response(
 427        Index=0,
 428        Type="RemoveProjects"
 429    )
 430    task = Task(Index=0, Type="RemoveProjects", Input=remove_projects_request, Output=remove_projects_response)
 431    self.SendTask(task)
 432    return task
 433
 434
 435def list_groups(self) -> Task:
 436
 437    """
 438     List the scan groups in the current open project.
 439    """
 440    list_groups_request = MF_V3_Tasks_ListGroups.Request(
 441        Index=0,
 442        Type="ListGroups"
 443    )
 444    list_groups_response = MF_V3_Tasks_ListGroups.Response(
 445        Index=0,
 446        Type="ListGroups",
 447        Output=None
 448    )
 449    task = Task(Index=0, Type="ListGroups", Input=list_groups_request, Output=list_groups_response)
 450    self.SendTask(task)
 451    return task
 452
 453
 454def list_scans(self) -> Task:
 455
 456    """
 457     List the scans in the current open project.
 458    """
 459    list_scans_request = MF_V3_Tasks_ListScans.Request(
 460        Index=0,
 461        Type="ListScans"
 462    )
 463    list_scans_response = MF_V3_Tasks_ListScans.Response(
 464        Index=0,
 465        Type="ListScans"
 466    )
 467    task = Task(Index=0, Type="ListScans", Input=list_scans_request, Output=list_scans_response)
 468    self.SendTask(task)
 469    return task
 470
 471
 472def scan_data(self, index: int, mergeStep: MF_V3_Settings_ScanData_ScanData.MergeStep = None, buffers: List[MF_V3_Settings_ScanData_ScanData.Buffer] = None, metadata: List[MF_V3_Settings_ScanData_ScanData.Metadata] = None) -> Task:
 473
 474    """
 475     Download the raw scan data for a scan in the current open project.
 476    """
 477    scan_data_request = MF_V3_Tasks_ScanData.Request(
 478        Index=0,
 479        Type="ScanData",
 480        Input=MF_V3_Settings_ScanData_ScanData(
 481            index=index,
 482            mergeStep=mergeStep,
 483            buffers=buffers,
 484            metadata=metadata,
 485        )
 486    )
 487    scan_data_response = MF_V3_Tasks_ScanData.Response(
 488        Index=0,
 489        Type="ScanData",
 490        Input=MF_V3_Settings_ScanData_ScanData(
 491            index=index,
 492            mergeStep=mergeStep,
 493            buffers=buffers,
 494            metadata=metadata,
 495        ),
 496        Output=None
 497    )
 498    task = Task(Index=0, Type="ScanData", Input=scan_data_request, Output=scan_data_response)
 499    self.SendTask(task)
 500    return task
 501
 502
 503def set_project(self, index: int = None, name: str = None) -> Task:
 504
 505    """
 506     Apply settings to the current open project.
 507    """
 508    set_project_request = MF_V3_Tasks_SetProject.Request(
 509        Index=0,
 510        Type="SetProject",
 511        Input=MF_V3_Settings_Project_Project(
 512            index=index,
 513            name=name,
 514        )
 515    )
 516    set_project_response = MF_V3_Tasks_SetProject.Response(
 517        Index=0,
 518        Type="SetProject"
 519    )
 520    task = Task(Index=0, Type="SetProject", Input=set_project_request, Output=set_project_response)
 521    self.SendTask(task)
 522    return task
 523
 524
 525def 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:
 526
 527    """
 528     Set scan group properties.
 529    """
 530    set_group_request = MF_V3_Tasks_SetGroup.Request(
 531        Index=0,
 532        Type="SetGroup",
 533        Input=MF_V3_Settings_Group_Group(
 534            index=index,
 535            name=name,
 536            color=color,
 537            visible=visible,
 538            collapsed=collapsed,
 539            rotation=rotation,
 540            translation=translation,
 541        )
 542    )
 543    set_group_response = MF_V3_Tasks_SetGroup.Response(
 544        Index=0,
 545        Type="SetGroup",
 546        Input=MF_V3_Settings_Group_Group(
 547            index=index,
 548            name=name,
 549            color=color,
 550            visible=visible,
 551            collapsed=collapsed,
 552            rotation=rotation,
 553            translation=translation,
 554        ),
 555        Output=None
 556    )
 557    task = Task(Index=0, Type="SetGroup", Input=set_group_request, Output=set_group_response)
 558    self.SendTask(task)
 559    return task
 560
 561
 562def 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:
 563
 564    """
 565     Create a new scan group.
 566    """
 567    new_group_request = MF_V3_Tasks_NewGroup.Request(
 568        Index=0,
 569        Type="NewGroup",
 570        Input=MF_V3_Settings_NewGroup_NewGroup(
 571            parentIndex=parentIndex,
 572            baseName=baseName,
 573            color=color,
 574            visible=visible,
 575            collapsed=collapsed,
 576            rotation=rotation,
 577            translation=translation,
 578        )
 579    )
 580    new_group_response = MF_V3_Tasks_NewGroup.Response(
 581        Index=0,
 582        Type="NewGroup",
 583        Output=None
 584    )
 585    task = Task(Index=0, Type="NewGroup", Input=new_group_request, Output=new_group_response)
 586    self.SendTask(task)
 587    return task
 588
 589
 590def move_group(self, Input: List[int] = None) -> Task:
 591
 592    """
 593     Move a scan group.
 594    """
 595    move_group_request = MF_V3_Tasks_MoveGroup.Request(
 596        Index=0,
 597        Type="MoveGroup",
 598        Input=Input
 599    )
 600    move_group_response = MF_V3_Tasks_MoveGroup.Response(
 601        Index=0,
 602        Type="MoveGroup",
 603        Output=None
 604    )
 605    task = Task(Index=0, Type="MoveGroup", Input=move_group_request, Output=move_group_response)
 606    self.SendTask(task)
 607    return task
 608
 609
 610def flatten_group(self, Input: int) -> Task:
 611
 612    """
 613     Flatten a scan group such that it only consists of single scans.
 614    """
 615    flatten_group_request = MF_V3_Tasks_FlattenGroup.Request(
 616        Index=0,
 617        Type="FlattenGroup",
 618        Input=Input
 619    )
 620    flatten_group_response = MF_V3_Tasks_FlattenGroup.Response(
 621        Index=0,
 622        Type="FlattenGroup",
 623        Input=Input,
 624        Output=None
 625    )
 626    task = Task(Index=0, Type="FlattenGroup", Input=flatten_group_request, Output=flatten_group_response)
 627    self.SendTask(task)
 628    return task
 629
 630
 631def split_group(self, Input: int) -> Task:
 632
 633    """
 634     Split a scan group (ie. move its subgroups to its parent group).
 635    """
 636    split_group_request = MF_V3_Tasks_SplitGroup.Request(
 637        Index=0,
 638        Type="SplitGroup",
 639        Input=Input
 640    )
 641    split_group_response = MF_V3_Tasks_SplitGroup.Response(
 642        Index=0,
 643        Type="SplitGroup",
 644        Input=Input,
 645        Output=None
 646    )
 647    task = Task(Index=0, Type="SplitGroup", Input=split_group_request, Output=split_group_response)
 648    self.SendTask(task)
 649    return task
 650
 651
 652def 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:
 653
 654    """
 655     Apply a rigid transformation to a group.
 656    """
 657    transform_group_request = MF_V3_Tasks_TransformGroup.Request(
 658        Index=0,
 659        Type="TransformGroup",
 660        Input=MF_V3_Settings_Group_Group(
 661            index=index,
 662            name=name,
 663            color=color,
 664            visible=visible,
 665            collapsed=collapsed,
 666            rotation=rotation,
 667            translation=translation,
 668        )
 669    )
 670    transform_group_response = MF_V3_Tasks_TransformGroup.Response(
 671        Index=0,
 672        Type="TransformGroup",
 673        Input=MF_V3_Settings_Group_Group(
 674            index=index,
 675            name=name,
 676            color=color,
 677            visible=visible,
 678            collapsed=collapsed,
 679            rotation=rotation,
 680            translation=translation,
 681        ),
 682        Output=None
 683    )
 684    task = Task(Index=0, Type="TransformGroup", Input=transform_group_request, Output=transform_group_response)
 685    self.SendTask(task)
 686    return task
 687
 688
 689def remove_groups(self, Input: List[int] = None) -> Task:
 690
 691    """
 692     Remove selected scan groups.
 693    """
 694    remove_groups_request = MF_V3_Tasks_RemoveGroups.Request(
 695        Index=0,
 696        Type="RemoveGroups",
 697        Input=Input
 698    )
 699    remove_groups_response = MF_V3_Tasks_RemoveGroups.Response(
 700        Index=0,
 701        Type="RemoveGroups",
 702        Output=None
 703    )
 704    task = Task(Index=0, Type="RemoveGroups", Input=remove_groups_request, Output=remove_groups_response)
 705    self.SendTask(task)
 706    return task
 707
 708
 709def bounding_box(self, selection: MF_V3_Settings_ScanSelection_ScanSelection, axisAligned: bool) -> Task:
 710
 711    """
 712     Get the bounding box of a set of scan groups.
 713    """
 714    bounding_box_request = MF_V3_Tasks_BoundingBox.Request(
 715        Index=0,
 716        Type="BoundingBox",
 717        Input=MF_V3_Settings_BoundingBox_BoundingBox(
 718            selection=selection,
 719            axisAligned=axisAligned,
 720        )
 721    )
 722    bounding_box_response = MF_V3_Tasks_BoundingBox.Response(
 723        Index=0,
 724        Type="BoundingBox",
 725        Input=MF_V3_Settings_BoundingBox_BoundingBox(
 726            selection=selection,
 727            axisAligned=axisAligned,
 728        ),
 729        Output=None
 730    )
 731    task = Task(Index=0, Type="BoundingBox", Input=bounding_box_request, Output=bounding_box_response)
 732    self.SendTask(task)
 733    return task
 734
 735
 736def align(self, source: int, target: int, rough: MF_V3_Settings_Align_Align.Rough = None, fine: MF_V3_Settings_Align_Align.Fine = None) -> Task:
 737
 738    """
 739     Align two scan groups.
 740    """
 741    align_request = MF_V3_Tasks_Align.Request(
 742        Index=0,
 743        Type="Align",
 744        Input=MF_V3_Settings_Align_Align(
 745            source=source,
 746            target=target,
 747            rough=rough,
 748            fine=fine,
 749        )
 750    )
 751    align_response = MF_V3_Tasks_Align.Response(
 752        Index=0,
 753        Type="Align",
 754        Input=MF_V3_Settings_Align_Align(
 755            source=source,
 756            target=target,
 757            rough=rough,
 758            fine=fine,
 759        ),
 760        Output=None
 761    )
 762    task = Task(Index=0, Type="Align", Input=align_request, Output=align_response)
 763    self.SendTask(task)
 764    return task
 765
 766
 767def heat_map(self, sources: List[int] = None, targets: List[int] = None, outlierDistance: float = None) -> Task:
 768
 769    """
 770     Compute the point-to-mesh distances of a source mesh to a target mesh and visualize as a heat map.
 771    """
 772    heat_map_request = MF_V3_Tasks_HeatMap.Request(
 773        Index=0,
 774        Type="HeatMap",
 775        Input=MF_V3_Settings_HeatMap_HeatMap(
 776            sources=sources,
 777            targets=targets,
 778            outlierDistance=outlierDistance,
 779        )
 780    )
 781    heat_map_response = MF_V3_Tasks_HeatMap.Response(
 782        Index=0,
 783        Type="HeatMap",
 784        Input=MF_V3_Settings_HeatMap_HeatMap(
 785            sources=sources,
 786            targets=targets,
 787            outlierDistance=outlierDistance,
 788        ),
 789        Output=None
 790    )
 791    task = Task(Index=0, Type="HeatMap", Input=heat_map_request, Output=heat_map_response)
 792    self.SendTask(task)
 793    return task
 794
 795
 796def merge(self, selection: MF_V3_Settings_ScanSelection_ScanSelection = None, remesh: MF_V3_Settings_Merge_Merge.Remesh = None, simplify: MF_V3_Settings_Merge_Merge.Simplify = None, texturize: bool = None) -> Task:
 797
 798    """
 799     Merge two or more scan groups.
 800    """
 801    merge_request = MF_V3_Tasks_Merge.Request(
 802        Index=0,
 803        Type="Merge",
 804        Input=MF_V3_Settings_Merge_Merge(
 805            selection=selection,
 806            remesh=remesh,
 807            simplify=simplify,
 808            texturize=texturize,
 809        )
 810    )
 811    merge_response = MF_V3_Tasks_Merge.Response(
 812        Index=0,
 813        Type="Merge",
 814        Input=MF_V3_Settings_Merge_Merge(
 815            selection=selection,
 816            remesh=remesh,
 817            simplify=simplify,
 818            texturize=texturize,
 819        ),
 820        Output=None
 821    )
 822    task = Task(Index=0, Type="Merge", Input=merge_request, Output=merge_response)
 823    self.SendTask(task)
 824    return task
 825
 826
 827def merge_data(self, index: int, mergeStep: MF_V3_Settings_ScanData_ScanData.MergeStep = None, buffers: List[MF_V3_Settings_ScanData_ScanData.Buffer] = None, metadata: List[MF_V3_Settings_ScanData_ScanData.Metadata] = None) -> Task:
 828
 829    """
 830     Download the raw scan data for the current merge process.
 831    """
 832    merge_data_request = MF_V3_Tasks_MergeData.Request(
 833        Index=0,
 834        Type="MergeData",
 835        Input=MF_V3_Settings_ScanData_ScanData(
 836            index=index,
 837            mergeStep=mergeStep,
 838            buffers=buffers,
 839            metadata=metadata,
 840        )
 841    )
 842    merge_data_response = MF_V3_Tasks_MergeData.Response(
 843        Index=0,
 844        Type="MergeData",
 845        Input=MF_V3_Settings_ScanData_ScanData(
 846            index=index,
 847            mergeStep=mergeStep,
 848            buffers=buffers,
 849            metadata=metadata,
 850        ),
 851        Output=None
 852    )
 853    task = Task(Index=0, Type="MergeData", Input=merge_data_request, Output=merge_data_response)
 854    self.SendTask(task)
 855    return task
 856
 857
 858def add_merge_to_project(self) -> Task:
 859
 860    """
 861     Add a merged scan to the current project.
 862    """
 863    add_merge_to_project_request = MF_V3_Tasks_AddMergeToProject.Request(
 864        Index=0,
 865        Type="AddMergeToProject"
 866    )
 867    add_merge_to_project_response = MF_V3_Tasks_AddMergeToProject.Response(
 868        Index=0,
 869        Type="AddMergeToProject",
 870        Output=None
 871    )
 872    task = Task(Index=0, Type="AddMergeToProject", Input=add_merge_to_project_request, Output=add_merge_to_project_response)
 873    self.SendTask(task)
 874    return task
 875
 876
 877def import_file(self, name: str = None, scale: float = None, unit: MF_V3_Settings_Import_Import.Unit = None, center: bool = None, groupIndex: int = None) -> Task:
 878
 879    """
 880     Import a set of 3D meshes to the current open project.  The meshes must be archived in a ZIP file.
 881    """
 882    import_file_request = MF_V3_Tasks_Import.Request(
 883        Index=0,
 884        Type="Import",
 885        Input=MF_V3_Settings_Import_Import(
 886            name=name,
 887            scale=scale,
 888            unit=unit,
 889            center=center,
 890            groupIndex=groupIndex,
 891        )
 892    )
 893    import_file_response = MF_V3_Tasks_Import.Response(
 894        Index=0,
 895        Type="Import"
 896    )
 897    task = Task(Index=0, Type="Import", Input=import_file_request, Output=import_file_response)
 898    self.SendTask(task)
 899    return task
 900
 901
 902def list_export_formats(self) -> Task:
 903
 904    """
 905     List all export formats.
 906    """
 907    list_export_formats_request = MF_V3_Tasks_ListExportFormats.Request(
 908        Index=0,
 909        Type="ListExportFormats"
 910    )
 911    list_export_formats_response = MF_V3_Tasks_ListExportFormats.Response(
 912        Index=0,
 913        Type="ListExportFormats"
 914    )
 915    task = Task(Index=0, Type="ListExportFormats", Input=list_export_formats_request, Output=list_export_formats_response)
 916    self.SendTask(task)
 917    return task
 918
 919
 920def export(self, selection: MF_V3_Settings_ScanSelection_ScanSelection = None, texture: bool = None, merge: bool = None, format: MF_V3_Settings_Export_Export.Format = None, scale: float = None, color: MF_V3_Settings_Export_Export.Color = None) -> Task:
 921
 922    """
 923     Export a group of scans.
 924    """
 925    export_request = MF_V3_Tasks_Export.Request(
 926        Index=0,
 927        Type="Export",
 928        Input=MF_V3_Settings_Export_Export(
 929            selection=selection,
 930            texture=texture,
 931            merge=merge,
 932            format=format,
 933            scale=scale,
 934            color=color,
 935        )
 936    )
 937    export_response = MF_V3_Tasks_Export.Response(
 938        Index=0,
 939        Type="Export",
 940        Input=MF_V3_Settings_Export_Export(
 941            selection=selection,
 942            texture=texture,
 943            merge=merge,
 944            format=format,
 945            scale=scale,
 946            color=color,
 947        )
 948    )
 949    task = Task(Index=0, Type="Export", Input=export_request, Output=export_response)
 950    self.SendTask(task)
 951    return task
 952
 953
 954def export_heat_map(self, selection: MF_V3_Settings_ScanSelection_ScanSelection = None, texture: bool = None, merge: bool = None, format: MF_V3_Settings_Export_Export.Format = None, scale: float = None, color: MF_V3_Settings_Export_Export.Color = None) -> Task:
 955
 956    """
 957     Export a mesh with vertex colors generated by the 'HeatMap' task.
 958    """
 959    export_heat_map_request = MF_V3_Tasks_ExportHeatMap.Request(
 960        Index=0,
 961        Type="ExportHeatMap",
 962        Input=MF_V3_Settings_Export_Export(
 963            selection=selection,
 964            texture=texture,
 965            merge=merge,
 966            format=format,
 967            scale=scale,
 968            color=color,
 969        )
 970    )
 971    export_heat_map_response = MF_V3_Tasks_ExportHeatMap.Response(
 972        Index=0,
 973        Type="ExportHeatMap",
 974        Input=MF_V3_Settings_Export_Export(
 975            selection=selection,
 976            texture=texture,
 977            merge=merge,
 978            format=format,
 979            scale=scale,
 980            color=color,
 981        )
 982    )
 983    task = Task(Index=0, Type="ExportHeatMap", Input=export_heat_map_request, Output=export_heat_map_response)
 984    self.SendTask(task)
 985    return task
 986
 987
 988def export_merge(self, selection: MF_V3_Settings_ScanSelection_ScanSelection = None, texture: bool = None, merge: bool = None, format: MF_V3_Settings_Export_Export.Format = None, scale: float = None, color: MF_V3_Settings_Export_Export.Color = None) -> Task:
 989
 990    """
 991     Export a merged scan.
 992    """
 993    export_merge_request = MF_V3_Tasks_ExportMerge.Request(
 994        Index=0,
 995        Type="ExportMerge",
 996        Input=MF_V3_Settings_Export_Export(
 997            selection=selection,
 998            texture=texture,
 999            merge=merge,
1000            format=format,
1001            scale=scale,
1002            color=color,
1003        )
1004    )
1005    export_merge_response = MF_V3_Tasks_ExportMerge.Response(
1006        Index=0,
1007        Type="ExportMerge",
1008        Input=MF_V3_Settings_Export_Export(
1009            selection=selection,
1010            texture=texture,
1011            merge=merge,
1012            format=format,
1013            scale=scale,
1014            color=color,
1015        )
1016    )
1017    task = Task(Index=0, Type="ExportMerge", Input=export_merge_request, Output=export_merge_response)
1018    self.SendTask(task)
1019    return task
1020
1021
1022def export_logs(self, Input: bool = None) -> Task:
1023
1024    """
1025     Export scanner logs.
1026    """
1027    export_logs_request = MF_V3_Tasks_ExportLogs.Request(
1028        Index=0,
1029        Type="ExportLogs",
1030        Input=Input
1031    )
1032    export_logs_response = MF_V3_Tasks_ExportLogs.Response(
1033        Index=0,
1034        Type="ExportLogs"
1035    )
1036    task = Task(Index=0, Type="ExportLogs", Input=export_logs_request, Output=export_logs_response)
1037    self.SendTask(task)
1038    return task
1039
1040
1041def has_cameras(self) -> Task:
1042
1043    """
1044     Check if the scanner has working cameras.
1045    """
1046    has_cameras_request = MF_V3_Tasks_HasCameras.Request(
1047        Index=0,
1048        Type="HasCameras"
1049    )
1050    has_cameras_response = MF_V3_Tasks_HasCameras.Response(
1051        Index=0,
1052        Type="HasCameras"
1053    )
1054    task = Task(Index=0, Type="HasCameras", Input=has_cameras_request, Output=has_cameras_response)
1055    self.SendTask(task)
1056    return task
1057
1058
1059def has_projector(self) -> Task:
1060
1061    """
1062     Check if the scanner has a working projector.
1063    """
1064    has_projector_request = MF_V3_Tasks_HasProjector.Request(
1065        Index=0,
1066        Type="HasProjector"
1067    )
1068    has_projector_response = MF_V3_Tasks_HasProjector.Response(
1069        Index=0,
1070        Type="HasProjector"
1071    )
1072    task = Task(Index=0, Type="HasProjector", Input=has_projector_request, Output=has_projector_response)
1073    self.SendTask(task)
1074    return task
1075
1076
1077def has_turntable(self) -> Task:
1078
1079    """
1080     Check if the scanner is connected to a working turntable.
1081    """
1082    has_turntable_request = MF_V3_Tasks_HasTurntable.Request(
1083        Index=0,
1084        Type="HasTurntable"
1085    )
1086    has_turntable_response = MF_V3_Tasks_HasTurntable.Response(
1087        Index=0,
1088        Type="HasTurntable"
1089    )
1090    task = Task(Index=0, Type="HasTurntable", Input=has_turntable_request, Output=has_turntable_response)
1091    self.SendTask(task)
1092    return task
1093
1094
1095def system_info(self, updateMajor: bool = None, updateNightly: bool = None) -> Task:
1096
1097    """
1098     Get system information.
1099    """
1100    system_info_request = MF_V3_Tasks_SystemInfo.Request(
1101        Index=0,
1102        Type="SystemInfo",
1103        Input=MF_V3_Settings_Software_Software(
1104            updateMajor=updateMajor,
1105            updateNightly=updateNightly,
1106        )
1107    )
1108    system_info_response = MF_V3_Tasks_SystemInfo.Response(
1109        Index=0,
1110        Type="SystemInfo",
1111        Output=None
1112    )
1113    task = Task(Index=0, Type="SystemInfo", Input=system_info_request, Output=system_info_response)
1114    self.SendTask(task)
1115    return task
1116
1117
1118def camera_calibration(self) -> Task:
1119
1120    """
1121     Get the camera calibration descriptor.
1122    """
1123    camera_calibration_request = MF_V3_Tasks_CameraCalibration.Request(
1124        Index=0,
1125        Type="CameraCalibration"
1126    )
1127    camera_calibration_response = MF_V3_Tasks_CameraCalibration.Response(
1128        Index=0,
1129        Type="CameraCalibration"
1130    )
1131    task = Task(Index=0, Type="CameraCalibration", Input=camera_calibration_request, Output=camera_calibration_response)
1132    self.SendTask(task)
1133    return task
1134
1135
1136def turntable_calibration(self) -> Task:
1137
1138    """
1139     Get the turntable calibration descriptor.
1140    """
1141    turntable_calibration_request = MF_V3_Tasks_TurntableCalibration.Request(
1142        Index=0,
1143        Type="TurntableCalibration"
1144    )
1145    turntable_calibration_response = MF_V3_Tasks_TurntableCalibration.Response(
1146        Index=0,
1147        Type="TurntableCalibration"
1148    )
1149    task = Task(Index=0, Type="TurntableCalibration", Input=turntable_calibration_request, Output=turntable_calibration_response)
1150    self.SendTask(task)
1151    return task
1152
1153
1154def calibration_capture_targets(self) -> Task:
1155
1156    """
1157     Get the calibration capture target for each camera calibration capture.
1158    """
1159    calibration_capture_targets_request = MF_V3_Tasks_CalibrationCaptureTargets.Request(
1160        Index=0,
1161        Type="CalibrationCaptureTargets"
1162    )
1163    calibration_capture_targets_response = MF_V3_Tasks_CalibrationCaptureTargets.Response(
1164        Index=0,
1165        Type="CalibrationCaptureTargets"
1166    )
1167    task = Task(Index=0, Type="CalibrationCaptureTargets", Input=calibration_capture_targets_request, Output=calibration_capture_targets_response)
1168    self.SendTask(task)
1169    return task
1170
1171
1172def calibrate_cameras(self) -> Task:
1173
1174    """
1175     Calibrate the cameras.
1176    """
1177    calibrate_cameras_request = MF_V3_Tasks_CalibrateCameras.Request(
1178        Index=0,
1179        Type="CalibrateCameras"
1180    )
1181    calibrate_cameras_response = MF_V3_Tasks_CalibrateCameras.Response(
1182        Index=0,
1183        Type="CalibrateCameras"
1184    )
1185    task = Task(Index=0, Type="CalibrateCameras", Input=calibrate_cameras_request, Output=calibrate_cameras_response)
1186    self.SendTask(task)
1187    return task
1188
1189
1190def calibrate_turntable(self) -> Task:
1191
1192    """
1193     Calibrate the turntable.
1194    """
1195    calibrate_turntable_request = MF_V3_Tasks_CalibrateTurntable.Request(
1196        Index=0,
1197        Type="CalibrateTurntable"
1198    )
1199    calibrate_turntable_response = MF_V3_Tasks_CalibrateTurntable.Response(
1200        Index=0,
1201        Type="CalibrateTurntable"
1202    )
1203    task = Task(Index=0, Type="CalibrateTurntable", Input=calibrate_turntable_request, Output=calibrate_turntable_response)
1204    self.SendTask(task)
1205    return task
1206
1207
1208def detect_calibration_card(self, Input: int) -> Task:
1209
1210    """
1211     Detect the calibration card on one or both cameras.
1212    """
1213    detect_calibration_card_request = MF_V3_Tasks_DetectCalibrationCard.Request(
1214        Index=0,
1215        Type="DetectCalibrationCard",
1216        Input=Input
1217    )
1218    detect_calibration_card_response = MF_V3_Tasks_DetectCalibrationCard.Response(
1219        Index=0,
1220        Type="DetectCalibrationCard",
1221        Input=Input
1222    )
1223    task = Task(Index=0, Type="DetectCalibrationCard", Input=detect_calibration_card_request, Output=detect_calibration_card_response)
1224    self.SendTask(task)
1225    return task
1226
1227
1228def restore_factory_calibration(self) -> Task:
1229
1230    """
1231     Restore factory calibration.
1232    """
1233    restore_factory_calibration_request = MF_V3_Tasks_RestoreFactoryCalibration.Request(
1234        Index=0,
1235        Type="RestoreFactoryCalibration"
1236    )
1237    restore_factory_calibration_response = MF_V3_Tasks_RestoreFactoryCalibration.Response(
1238        Index=0,
1239        Type="RestoreFactoryCalibration"
1240    )
1241    task = Task(Index=0, Type="RestoreFactoryCalibration", Input=restore_factory_calibration_request, Output=restore_factory_calibration_response)
1242    self.SendTask(task)
1243    return task
1244
1245
1246def start_video(self) -> Task:
1247
1248    """
1249     Start the video stream.
1250    """
1251    start_video_request = MF_V3_Tasks_StartVideo.Request(
1252        Index=0,
1253        Type="StartVideo"
1254    )
1255    start_video_response = MF_V3_Tasks_StartVideo.Response(
1256        Index=0,
1257        Type="StartVideo"
1258    )
1259    task = Task(Index=0, Type="StartVideo", Input=start_video_request, Output=start_video_response)
1260    self.SendTask(task)
1261    return task
1262
1263
1264def stop_video(self) -> Task:
1265
1266    """
1267     Stop the video stream.
1268    """
1269    stop_video_request = MF_V3_Tasks_StopVideo.Request(
1270        Index=0,
1271        Type="StopVideo"
1272    )
1273    stop_video_response = MF_V3_Tasks_StopVideo.Response(
1274        Index=0,
1275        Type="StopVideo"
1276    )
1277    task = Task(Index=0, Type="StopVideo", Input=stop_video_request, Output=stop_video_response)
1278    self.SendTask(task)
1279    return task
1280
1281
1282def set_cameras(self, selection: List[int] = None, autoExposure: bool = None, exposure: int = None, analogGain: float = None, digitalGain: int = None, focus: int = None) -> Task:
1283
1284    """
1285     Apply camera settings to one or both cameras.
1286    """
1287    set_cameras_request = MF_V3_Tasks_SetCameras.Request(
1288        Index=0,
1289        Type="SetCameras",
1290        Input=MF_V3_Settings_Camera_Camera(
1291            selection=selection,
1292            autoExposure=autoExposure,
1293            exposure=exposure,
1294            analogGain=analogGain,
1295            digitalGain=digitalGain,
1296            focus=focus,
1297        )
1298    )
1299    set_cameras_response = MF_V3_Tasks_SetCameras.Response(
1300        Index=0,
1301        Type="SetCameras"
1302    )
1303    task = Task(Index=0, Type="SetCameras", Input=set_cameras_request, Output=set_cameras_response)
1304    self.SendTask(task)
1305    return task
1306
1307
1308def set_projector(self, on: bool = None, brightness: float = None, pattern: MF_V3_Settings_Projector_Projector.Pattern = None, image: MF_V3_Settings_Projector_Projector.Image = None, color: List[float] = None, buffer: bytes = None) -> Task:
1309
1310    """
1311     Apply projector settings.
1312    """
1313    set_projector_request = MF_V3_Tasks_SetProjector.Request(
1314        Index=0,
1315        Type="SetProjector",
1316        Input=MF_V3_Settings_Projector_Projector(
1317            on=on,
1318            brightness=brightness,
1319            pattern=pattern,
1320            image=image,
1321            color=color,
1322        )
1323    )
1324    set_projector_response = MF_V3_Tasks_SetProjector.Response(
1325        Index=0,
1326        Type="SetProjector"
1327    )
1328    task = Task(Index=0, Type="SetProjector", Input=set_projector_request, Output=set_projector_response)
1329    self.SendTask(task, buffer)
1330    return task
1331
1332
1333def auto_focus(self, applyAll: bool, cameras: List[MF_V3_Settings_AutoFocus_AutoFocus.Camera] = None) -> Task:
1334
1335    """
1336     Auto focus one or both cameras.
1337    """
1338    auto_focus_request = MF_V3_Tasks_AutoFocus.Request(
1339        Index=0,
1340        Type="AutoFocus",
1341        Input=MF_V3_Settings_AutoFocus_AutoFocus(
1342            applyAll=applyAll,
1343            cameras=cameras,
1344        )
1345    )
1346    auto_focus_response = MF_V3_Tasks_AutoFocus.Response(
1347        Index=0,
1348        Type="AutoFocus"
1349    )
1350    task = Task(Index=0, Type="AutoFocus", Input=auto_focus_request, Output=auto_focus_response)
1351    self.SendTask(task)
1352    return task
1353
1354
1355def rotate_turntable(self, Input: int) -> Task:
1356
1357    """
1358     Rotate the turntable.
1359    """
1360    rotate_turntable_request = MF_V3_Tasks_RotateTurntable.Request(
1361        Index=0,
1362        Type="RotateTurntable",
1363        Input=Input
1364    )
1365    rotate_turntable_response = MF_V3_Tasks_RotateTurntable.Response(
1366        Index=0,
1367        Type="RotateTurntable",
1368        Input=Input
1369    )
1370    task = Task(Index=0, Type="RotateTurntable", Input=rotate_turntable_request, Output=rotate_turntable_response)
1371    self.SendTask(task)
1372    return task
1373
1374
1375def new_scan(self, camera: MF_V3_Settings_Camera_Camera = None, projector: MF_V3_Settings_Projector_Projector = None, turntable: MF_V3_Settings_Turntable_Turntable = None, capture: MF_V3_Settings_Capture_Capture = None, processing: MF_V3_Settings_Scan_Scan.Processing = None, alignWithScanner: bool = None, centerAtOrigin: bool = None) -> Task:
1376
1377    """
1378     Capture a new scan.
1379    """
1380    new_scan_request = MF_V3_Tasks_NewScan.Request(
1381        Index=0,
1382        Type="NewScan",
1383        Input=MF_V3_Settings_Scan_Scan(
1384            camera=camera,
1385            projector=projector,
1386            turntable=turntable,
1387            capture=capture,
1388            processing=processing,
1389            alignWithScanner=alignWithScanner,
1390            centerAtOrigin=centerAtOrigin,
1391        )
1392    )
1393    new_scan_response = MF_V3_Tasks_NewScan.Response(
1394        Index=0,
1395        Type="NewScan"
1396    )
1397    task = Task(Index=0, Type="NewScan", Input=new_scan_request, Output=new_scan_response)
1398    self.SendTask(task)
1399    return task
1400
1401
1402def capture_image(self, selection: List[int] = None, codec: MF_V3_Settings_CaptureImage_CaptureImage.Codec = None, grayscale: bool = None) -> Task:
1403
1404    """
1405     Capture a single Image.
1406    """
1407    capture_image_request = MF_V3_Tasks_CaptureImage.Request(
1408        Index=0,
1409        Type="CaptureImage",
1410        Input=MF_V3_Settings_CaptureImage_CaptureImage(
1411            selection=selection,
1412            codec=codec,
1413            grayscale=grayscale,
1414        )
1415    )
1416    capture_image_response = MF_V3_Tasks_CaptureImage.Response(
1417        Index=0,
1418        Type="CaptureImage",
1419        Input=MF_V3_Settings_CaptureImage_CaptureImage(
1420            selection=selection,
1421            codec=codec,
1422            grayscale=grayscale,
1423        )
1424    )
1425    task = Task(Index=0, Type="CaptureImage", Input=capture_image_request, Output=capture_image_response)
1426    self.SendTask(task)
1427    return task
1428
1429
1430def depth_map(self, camera: MF_V3_Settings_Camera_Camera = None, projector: MF_V3_Settings_Projector_Projector = None, turntable: MF_V3_Settings_Turntable_Turntable = None, capture: MF_V3_Settings_Capture_Capture = None, processing: MF_V3_Settings_Scan_Scan.Processing = None, alignWithScanner: bool = None, centerAtOrigin: bool = None) -> Task:
1431
1432    """
1433     Capture a depth map.
1434    """
1435    depth_map_request = MF_V3_Tasks_DepthMap.Request(
1436        Index=0,
1437        Type="DepthMap",
1438        Input=MF_V3_Settings_Scan_Scan(
1439            camera=camera,
1440            projector=projector,
1441            turntable=turntable,
1442            capture=capture,
1443            processing=processing,
1444            alignWithScanner=alignWithScanner,
1445            centerAtOrigin=centerAtOrigin,
1446        )
1447    )
1448    depth_map_response = MF_V3_Tasks_DepthMap.Response(
1449        Index=0,
1450        Type="DepthMap"
1451    )
1452    task = Task(Index=0, Type="DepthMap", Input=depth_map_request, Output=depth_map_response)
1453    self.SendTask(task)
1454    return task
1455
1456
1457def reboot(self) -> Task:
1458
1459    """
1460     Reboot the scanner.
1461    """
1462    reboot_request = MF_V3_Tasks_Reboot.Request(
1463        Index=0,
1464        Type="Reboot"
1465    )
1466    reboot_response = MF_V3_Tasks_Reboot.Response(
1467        Index=0,
1468        Type="Reboot"
1469    )
1470    task = Task(Index=0, Type="Reboot", Input=reboot_request, Output=reboot_response)
1471    self.SendTask(task)
1472    return task
1473
1474
1475def shutdown(self) -> Task:
1476
1477    """
1478     Shutdown the scanner.
1479    """
1480    shutdown_request = MF_V3_Tasks_Shutdown.Request(
1481        Index=0,
1482        Type="Shutdown"
1483    )
1484    shutdown_response = MF_V3_Tasks_Shutdown.Response(
1485        Index=0,
1486        Type="Shutdown"
1487    )
1488    task = Task(Index=0, Type="Shutdown", Input=shutdown_request, Output=shutdown_response)
1489    self.SendTask(task)
1490    return task