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