Duplicate from fengtt42/U2USim-2

Co-authored-by: Anonymous42 <fengtt42@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,78 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Linux_version/Landscape3/Binaries/Linux/Landscape3-Linux-Shipping filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Linux_version/Landscape3/Content/Paks/Landscape3-Linux.pak filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Engine/Binaries/ThirdParty/DbgHelp/dbghelp.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Engine/Binaries/ThirdParty/NVIDIA/NVaftermath/Win64/GFSDK_Aftermath_Lib.x64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Engine/Binaries/ThirdParty/Vorbis/Win64/VS2015/libvorbis_64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Engine/Binaries/ThirdParty/Windows/XAudio2_9/x64/xaudio2_9redist.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Engine/Extras/Redist/en-us/UEPrereqSetup_x64.exe filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3.exe filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_filesystem-mt-x64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_program_options-mt-x64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_python39-mt-x64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_regex-mt-x64.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/D3D12/D3D12Core.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/Landscape3-Win64-Shipping.exe filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/OpenImageDenoise.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/tbb.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/tbb.pdb filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Binaries/Win64/tbb12.dll filter=lfs diff=lfs merge=lfs -text
+U2USim_2_Windows_version/Landscape3/Content/Paks/Landscape3-Windows.pak filter=lfs diff=lfs merge=lfs -text

AirDrone/.gitignore

@@ -0,0 +1,8 @@
+################################################################################
+# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。
+################################################################################
+
+/.vs/AirDroneClient
+/.idea
+/env
+*.pyc

AirDrone/AirDroneClient.py

@@ -0,0 +1,336 @@
+import sys
+from dataclasses import dataclass
+
+from PyQt5.QtCore import *
+from PyQt5.QtWidgets import *
+import keyboard
+
+import DroneController  # 假设只需要无人机控制
+
+# mobile configuration
+@dataclass
+class Vehicle():
+    acc = 1
+    vehicle_type = 'drone'  # 设置为无人机模式
+
+veh = Vehicle()
+
+# form application #
+app = QApplication(sys.argv)
+
+class AirDroneClientWindow(QWidget):
+    button_takeoff = QPushButton()
+    button_land = QPushButton()
+    button_up = QPushButton()
+    button_down = QPushButton()
+    
+    button_f = QPushButton()
+    button_b = QPushButton()
+    button_l = QPushButton()
+    button_r = QPushButton()
+    
+    button_weather = QPushButton()
+    button_task = QPushButton()
+    button_algorithm = QPushButton()
+    button_formation = QPushButton()
+    button_keyboard = QPushButton()
+    
+    weather_selection = QComboBox()
+    
+    label_gps_alt = QLabel()
+    label_gps_lat = QLabel()
+    label_gps_lon = QLabel()
+    label_rot_w = QLabel()
+    label_rot_y = QLabel()
+    label_rot_z = QLabel()
+    label_speed = QLabel()
+    label_angle_speed = QLabel()
+
+    refreshinfo = QTimer()
+
+    def initUI(self):
+        self.resize(500, 400)  # 调整为更合适的尺寸
+        self.setWindowTitle("U21Data-2 Client")
+
+        #self.set_background()
+
+        self.setObjectName("AirDroneClientWindow")  # 设置对象名称匹配选择器
+    
+
+        self.setStyleSheet(self.styleSheet())
+
+        # 主垂直布局
+        main_layout = QVBoxLayout()
+        
+        # 添加Start Point部分
+        start_group = QGroupBox("Start Point")
+        start_layout = QHBoxLayout()
+
+        self.start_combo = QComboBox()
+        self.start_combo.setEditable(True)
+        self.start_combo.lineEdit().setReadOnly(True)
+        self.start_combo.lineEdit().setAlignment(Qt.AlignCenter)
+        self.start_combo.addItems(["9.8, -279, -22", "213, -429, 19","-315, -444, 12", "-335, 282, 19", "-152, 236, 66", "-430, -91, 13"])
+        self.start_combo.setCurrentIndex(-1)
+        self.start_combo.lineEdit().setPlaceholderText("StartPoint")
+    
+
+        self.weather_selection = QComboBox()
+        self.weather_selection.setEditable(True)
+        self.weather_selection.lineEdit().setReadOnly(True)
+        self.weather_selection.lineEdit().setAlignment(Qt.AlignCenter)
+        self.weather_selection.addItems(["Clear", "Rain", "Snow", "Fog", "Overcast","Sand"])
+        self.weather_selection.setCurrentIndex(-1)
+        self.weather_selection.lineEdit().setPlaceholderText("Weather")
+    
+        for widget in [self.start_combo, self.weather_selection]:
+            widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+    
+        start_layout.addWidget(self.start_combo)
+        start_layout.addWidget(self.weather_selection)
+        start_group.setLayout(start_layout)
+        
+        # 添加功能按钮部分
+        func_group = QGroupBox("Functions")
+        func_layout = QHBoxLayout()
+    
+        self.button_keyboard = QComboBox()
+        self.button_keyboard.setEditable(True)
+        self.button_keyboard.lineEdit().setReadOnly(True)
+        self.button_keyboard.lineEdit().setAlignment(Qt.AlignCenter)
+        self.button_keyboard.addItems(["Yes", "No"])
+        self.button_keyboard.setCurrentIndex(-1)
+        self.button_keyboard.lineEdit().setPlaceholderText("Task")
+
+
+
+        #Task
+        self.task_combo = QComboBox()
+        self.task_combo.setEditable(True)  # 设置为可编辑
+        self.task_combo.lineEdit().setReadOnly(True)  # 设置行编辑为只读
+        self.task_combo.lineEdit().setAlignment(Qt.AlignCenter)  # 文字居中
+        self.task_combo.addItems(["Task 1", "Task 2", "Task 3"])
+        self.task_combo.setCurrentIndex(-1)  # 不选中任何项
+        self.task_combo.lineEdit().setPlaceholderText("Task")
+
+    
+        # 设置Algorithm下拉框选项
+        self.algorithm_combo = QComboBox()
+        self.algorithm_combo.setEditable(True)  # 设置为可编辑
+        self.algorithm_combo.lineEdit().setReadOnly(True)  # 设置行编辑为只读
+        self.algorithm_combo.lineEdit().setAlignment(Qt.AlignCenter)  # 文字居中
+        self.algorithm_combo.addItems(["Algorithm 1", "Algorithm 2", "Algorithm 3"])
+        self.algorithm_combo.setCurrentIndex(-1)  # 不选中任何项
+        self.algorithm_combo.lineEdit().setPlaceholderText("Algorithm")  # 设置占位文本
+
+        # 设置Formation下拉框选项
+        self.formation_combo = QComboBox()
+        self.formation_combo.setEditable(True)
+        self.formation_combo.lineEdit().setReadOnly(True)
+        self.formation_combo.lineEdit().setAlignment(Qt.AlignCenter)
+        self.formation_combo.addItems(["Line Formation", "V Formation", "Square Formation", "Circle Formation"])
+        self.formation_combo.setCurrentIndex(-1)
+        self.formation_combo.lineEdit().setPlaceholderText("Formation")
+    
+        # 设置控件大小策略
+        for widget in [self.task_combo, self.algorithm_combo, 
+                       self.formation_combo, self.button_keyboard]:
+            widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+    
+        # 添加控件到布局
+        func_layout.addWidget(self.task_combo)
+        func_layout.addWidget(self.algorithm_combo)
+        func_layout.addWidget(self.formation_combo)
+        func_layout.addWidget(self.button_keyboard)
+        func_group.setLayout(func_layout)
+        
+        # 添加飞行控制部分
+        flight_group = QGroupBox("Flight Controls")
+        flight_layout = QVBoxLayout()
+
+        # 将Takeoff, Land, Up, Down四个按钮放在同一行
+        top_row_layout = QHBoxLayout()
+        self.button_takeoff = QPushButton("Takeoff")
+        self.button_land = QPushButton("Land")
+        self.button_up = QPushButton("Up")
+        self.button_down = QPushButton("Down")
+
+        # 设置按钮大小策略，使它们均匀分布
+        for button in [self.button_takeoff, self.button_land, 
+                       self.button_up, self.button_down]:
+            button.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+
+        top_row_layout.addWidget(self.button_takeoff)
+        top_row_layout.addWidget(self.button_land)
+        top_row_layout.addWidget(self.button_up)
+        top_row_layout.addWidget(self.button_down)
+        top_row_layout.setSpacing(5)  # 设置按钮间距
+        
+        # 前后左右
+        move_layout = QGridLayout()
+        self.button_f = QPushButton("Move Forward")
+        self.button_b = QPushButton("Move Backward")
+        self.button_l = QPushButton("Move Left")
+        self.button_r = QPushButton("Move Right")
+        move_layout.addWidget(self.button_f, 0, 1)
+        move_layout.addWidget(self.button_b, 2, 1)
+        move_layout.addWidget(self.button_l, 1, 0)
+        move_layout.addWidget(self.button_r, 1, 2)
+
+        flight_layout.addLayout(top_row_layout)
+        flight_layout.addLayout(move_layout)
+        flight_group.setLayout(flight_layout)
+        
+        # 添加日志信息部分
+        log_group = QGroupBox("Log")
+        log_layout = QVBoxLayout()
+        self.label_gps_alt = QLabel("GPS Altitude: ")
+        self.label_gps_lat = QLabel("GPS Latitude: ")
+        self.label_gps_lon = QLabel("GPS Longitude: ")
+        self.label_rot_w = QLabel("Rotation w: ")
+        self.label_rot_y = QLabel("Rotation y: ")
+        self.label_rot_z = QLabel("Rotation z: ")
+        self.label_speed = QLabel("Linear Speed: ")
+        self.label_angle_speed = QLabel("Angle Speed: ")
+        
+        log_layout.addWidget(self.label_gps_alt)
+        log_layout.addWidget(self.label_gps_lat)
+        log_layout.addWidget(self.label_gps_lon)
+        log_layout.addWidget(self.label_rot_w)
+        log_layout.addWidget(self.label_rot_y)
+        log_layout.addWidget(self.label_rot_z)
+        log_layout.addWidget(self.label_speed)
+        log_layout.addWidget(self.label_angle_speed)
+        log_group.setLayout(log_layout)
+        
+        # 将所有组添加到主布局
+        main_layout.addWidget(start_group)
+        main_layout.addWidget(func_group)
+        main_layout.addWidget(flight_group)
+        main_layout.addWidget(log_group)
+        
+        self.setLayout(main_layout)
+        
+        # 连接信号槽
+        self.button_takeoff.clicked.connect(DroneController.dronecontrol.TakeOff)
+        self.button_land.clicked.connect(DroneController.dronecontrol.Landed)
+        self.button_up.clicked.connect(self.up)
+        self.button_down.clicked.connect(self.down)
+        self.button_f.pressed.connect(self.forward)
+        self.button_b.pressed.connect(self.backward)
+        self.button_l.pressed.connect(self.left)
+        self.button_r.pressed.connect(self.right)
+        self.button_f.released.connect(self.stop)
+        self.button_b.released.connect(self.stop)
+        self.button_l.released.connect(self.stop)
+        self.button_r.released.connect(self.stop)
+        self.button_keyboard.currentIndexChanged.connect(self.EnableKeyboard)
+        self.weather_selection.currentIndexChanged.connect(self.change_weather)
+        self.algorithm_combo.currentIndexChanged.connect(self.on_algorithm_changed)
+        self.formation_combo.currentIndexChanged.connect(self.on_formation_changed)
+        self.task_combo.currentIndexChanged.connect(self.on_task_changed)
+        self.start_combo.currentIndexChanged.connect(self.on_start_changed)
+        
+        # 自动刷新信息
+        self.refreshinfo.start(1000)
+        self.refreshinfo.timeout.connect(self.setInfo)
+
+        self.show()
+
+    def setInfo(self):
+        self.label_gps_alt.setText("GPS Altitude: " + str(DroneController.dronecontrol.GetState().gps_pos_altitude))
+        self.label_gps_lat.setText("GPS Latitude: " + str(DroneController.dronecontrol.GetState().gps_pos_latitude))
+        self.label_gps_lon.setText("GPS Longitude: " + str(DroneController.dronecontrol.GetState().gps_pos_longitude))
+        
+        self.label_rot_w.setText("Rotation w: " + str(DroneController.dronecontrol.GetState().ori_x))
+        self.label_rot_y.setText("Rotation y: " + str(DroneController.dronecontrol.GetState().ori_y))
+        self.label_rot_z.setText("Rotation z: " + str(DroneController.dronecontrol.GetState().ori_z))
+        
+        self.label_speed.setText("Linear Speed: " + str(DroneController.dronecontrol.GetState().linear_speed))
+        self.label_angle_speed.setText("Angle Speed: " + str(DroneController.dronecontrol.GetState().a_v_x))
+
+    # 移动功能
+    def forward(self):
+        DroneController.dronecontrol.DroneMoveByTime(veh.acc, 0, 0)
+
+    def backward(self):
+        DroneController.dronecontrol.DroneMoveByTime(-veh.acc, 0, 0)
+
+    def left(self):
+        DroneController.dronecontrol.DroneMoveByTime(0, -veh.acc, 0)
+
+    def right(self):
+        DroneController.dronecontrol.DroneMoveByTime(0, veh.acc, 0)
+
+    def stop(self):
+        pass
+
+    def up(self):
+        DroneController.dronecontrol.DroneMoveByTime(0, 0, -veh.acc)
+
+    def down(self):
+        DroneController.dronecontrol.DroneMoveByTime(0, 0, veh.acc)
+        
+    def change_weather(self, index):
+        if index >= 0:
+            weather = self.weather_selection.currentText()
+            if weather == "Snow":
+                DroneController.dronecontrol.SnowTeleport()
+            elif weather == "Rain":
+                DroneController.dronecontrol.RainTeleport()
+            elif weather == "Fog":
+                DroneController.dronecontrol.FogTeleport()
+            elif weather == "Overcast":
+                DroneController.dronecontrol.OvercastTeleport()
+            elif weather == "Clear":
+                DroneController.dronecontrol.ClearTeleport()
+            elif weather == "Sand":
+                DroneController.dronecontrol.SandTeleport()
+
+    def on_algorithm_changed(self, index):
+        """Algorithm下拉框选择变化时的处理"""
+        if index >= 0:
+            selected_algorithm = self.algorithm_combo.currentText()
+            print(f"Selected Algorithm: {selected_algorithm}")
+
+
+    def on_formation_changed(self, index):
+        """Formation下拉框选择变化时的处理"""
+        if index >= 0:
+            selected_formation = self.formation_combo.currentText()
+            print(f"Selected Formation: {selected_formation}")
+
+
+    def on_task_changed(self, index):
+        """Task下拉框选择变化时的处理"""
+        if index >= 0:
+            selected_task = self.task_combo.currentText()
+            print(f"Selected Task: {selected_task}")
+
+
+    def on_start_changed(self, index):
+        if index >= 0:
+            pos = self.start_combo.currentText()
+            if pos == "9.8, -279, -22":
+                DroneController.dronecontrol.SnowTeleport()
+            elif pos == "213, -429, 19":
+                DroneController.dronecontrol.OvercastTeleport()
+            elif pos == "-315, -444, 12":
+                DroneController.dronecontrol.RainTeleport()
+            elif pos == "-335, 282, 19":
+                DroneController.dronecontrol.SandTeleport()
+            elif pos == "-152, 236, 66":
+                DroneController.dronecontrol.ClearTeleport()
+            elif pos == "-430, -91, 13":
+                DroneController.dronecontrol.FogTeleport()
+            else:
+                print(self.start_combo.currentIndex())
+
+    def EnableKeyboard(self):
+        keyboard.hook(DroneController.dronecontrol.KeyboardControl)
+        keyboard.wait()
+
+window = AirDroneClientWindow()
+window.initUI()
+window.setInfo()
+sys.exit(app.exec())

AirDrone/AirDroneClient.pyproj

@@ -0,0 +1,51 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>4e90b183-6758-4994-8334-cfa6a07c9508</ProjectGuid>
+    <ProjectHome>.</ProjectHome>
+    <StartupFile>DroneController.py</StartupFile>
+    <SearchPath>
+    </SearchPath>
+    <WorkingDirectory>.</WorkingDirectory>
+    <OutputPath>.</OutputPath>
+    <Name>AirDroneClient</Name>
+    <RootNamespace>AirDroneClient</RootNamespace>
+    <InterpreterId>MSBuild|env|$(MSBuildProjectFullPath)</InterpreterId>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="AirDroneClient.py" />
+    <Compile Include="CarController.py" />
+    <Compile Include="DroneController.py" />
+    <Compile Include="FileConverter.py" />
+    <Compile Include="SeqOutputer.py" />
+  </ItemGroup>
+  <ItemGroup>
+    <Interpreter Include="env\">
+      <Id>env</Id>
+      <Version>3.11</Version>
+      <Description>env (Python 3.11 (64-bit))</Description>
+      <InterpreterPath>Scripts\python.exe</InterpreterPath>
+      <WindowsInterpreterPath>Scripts\pythonw.exe</WindowsInterpreterPath>
+      <PathEnvironmentVariable>PYTHONPATH</PathEnvironmentVariable>
+      <Architecture>X64</Architecture>
+    </Interpreter>
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />
+  <!-- Uncomment the CoreCompile target to enable the Build command in
+       Visual Studio and specify your pre- and post-build commands in
+       the BeforeBuild and AfterBuild targets below. -->
+  <!--<Target Name="CoreCompile" />-->
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+</Project>

AirDrone/AirDroneClient.pyproj.user

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectView>ProjectFiles</ProjectView>
+  </PropertyGroup>
+</Project>

AirDrone/AirDroneClient.sln

@@ -0,0 +1,23 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.7.34202.233
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "AirDroneClient", "AirDroneClient.pyproj", "{4E90B183-6758-4994-8334-CFA6A07C9508}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{4E90B183-6758-4994-8334-CFA6A07C9508}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4E90B183-6758-4994-8334-CFA6A07C9508}.Release|Any CPU.ActiveCfg = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {65CCDCFD-026C-4C90-A618-CF4FBBFB37AD}
+	EndGlobalSection
+EndGlobal

AirDrone/CarController.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+import airsim
+import time
+
+
+@dataclass
+class Carinfo():
+    speed_a = 0
+    speed_l = 0
+    
+    pos_x = 0
+    pos_y = 0
+    pos_z = 0
+    
+    rot_x = 0
+    rot_y = 0
+    rot_z = 0
+    
+
+class CarController():
+    def __init__(self):
+        # connect to the AirSim simulator
+        self.client = airsim.CarClient()
+        self.client.confirmConnection()
+        self.client.enableApiControl(True)
+        self.car_controls = airsim.CarControls()  
+
+    def GoForward(self, v):
+        self.car_controls.throttle = v
+        self.car_controls.steering = 0
+        self.client.setCarControls(self.car_controls)
+
+    def GoBackwardStart(self, v):
+        self.car_controls.throttle = v
+        self.car_controls.is_manual_gear = True
+        self.car_controls.manual_gear = -1
+        self.car_controls.steering = 0
+        self.client.setCarControls(self.car_controls)
+
+    def GoBackwardEnd(self):
+        self.car_controls.throttle = 0
+        self.car_controls.steering = 0
+        self.car_controls.is_manual_gear = False
+        self.car_controls.manual_gear = 0
+        self.client.setCarControls(self.car_controls)
+
+    def Steer(self, v, steering):
+        self.car_controls.throttle = v
+        self.car_controls.steering = steering
+        self.client.setCarControls(self.car_controls)
+
+    def Stop(self):
+        self.car_controls.throttle = 0
+        self.car_controls.steering = 0
+        self.client.setCarControls(self.car_controls)
+        
+    def GetCarPose(self):
+        position = self.client.simGetVehiclePose().position
+        rotation = self.client.simGetVehiclePose().orientation
+
+        speed_a = self.client.getCarState().speed
+        speed_l = self.client.getCarState().speed
+        
+        carinfo = Carinfo()
+        
+        carinfo.rot_x = rotation.x_val
+        carinfo.rot_y = rotation.y_val
+        carinfo.rot_z = rotation.z_val
+        
+        carinfo.pos_x = position.x_val
+        carinfo.pos_y = position.y_val
+        carinfo.pos_z = position.z_val
+        
+        carinfo.speed_a = speed_a
+        carinfo.speed_l = speed_l
+        
+        return carinfo
+        
+        
+carcontrol = CarController()

AirDrone/DroneController.py

@@ -0,0 +1,256 @@
+from multiprocessing import Value
+import airsim
+import time
+import math
+import keyboard
+import json
+
+class DroneInfo():
+    gps_pos_altitude = 0
+    gps_pos_latitude = 0
+    gps_pos_longitude = 0
+
+    ori_w = 0
+    ori_x = 0
+    ori_y = 0
+    ori_z = 0
+
+    # linear_velocity
+    l_v_x = 0
+    l_v_y = 0
+    l_v_z = 0
+
+    # angular_velocity
+    a_v_x = 0
+    a_v_y = 0
+    a_v_z = 0
+
+    roll = 0
+    yaw = 0
+    pitch = 0
+
+    linear_speed = 0
+
+
+class Drone():
+    def __init__(self):
+        # connect to the AirSim simulator
+        self.client = airsim.MultirotorClient()
+        self.client.confirmConnection()
+        self.client.enableApiControl(True)
+        self.client.armDisarm(True)
+
+    def TakeOff(self):
+        if airsim.LandedState.Landed == 0:
+            self.client.takeoffAsync().join()
+            print("take off")
+        else:
+            self.client.hoverAsync().join()
+            print("already flying")
+
+    def Landed(self):
+        if airsim.LandedState.Landed == 1:
+            print("already landed")
+        else:
+            self.client.landAsync().join()
+            print("now landing")
+
+    def DroneMoveByTime(self, vx, vy, vz, duration=3):
+        print("now speed", vx, vy, vz)
+        self.client.moveByVelocityAsync(vx, vy, vz, duration)
+        time.sleep(duration)
+        print("End Moving")
+
+    def GetState(self):
+        # State = self.client.getMultirotorState()
+        State = DroneInfo()
+        gps_pos = self.client.getMultirotorState().gps_location
+        State.gps_pos_altitude = gps_pos.altitude
+        State.gps_pos_longitude = gps_pos.longitude
+        State.gps_pos_latitude = gps_pos.latitude
+
+        orientation = self.client.getMultirotorState().kinematics_estimated.orientation
+        State.ori_w = orientation.w_val
+        State.ori_x = orientation.x_val
+        State.ori_y = orientation.y_val
+        State.ori_z = orientation.z_val
+
+        a_velocity = self.client.getMultirotorState().kinematics_estimated.angular_velocity
+        State.a_v_x = a_velocity.x_val
+        State.a_v_y = a_velocity.y_val
+        State.a_v_z = a_velocity.z_val
+
+        l_velocity = self.client.getMultirotorState().kinematics_estimated.linear_velocity
+        State.l_v_x = l_velocity.x_val
+        State.l_v_y = l_velocity.y_val
+        State.l_v_z = l_velocity.z_val
+
+        State.roll = self.client.getMultirotorState().rc_data.roll
+        State.yaw = self.client.getMultirotorState().rc_data.yaw
+        State.pitch = self.client.getMultirotorState().rc_data.pitch
+
+        State.linear_speed = math.sqrt(pow(State.l_v_x,2)+pow(State.l_v_y,2)+pow(State.l_v_z,2))
+
+        return State
+
+    def Hover(self):
+        landed = self.client.getMultirotorState()
+
+    def MoveToPosition(self,x,y,z,duration=3):
+        self.client.moveToPositionAsync(x, y, z, duration).join()
+
+    def Reset(self):
+        self.client.reset()
+
+    def SnowTeleport(self):
+        position = airsim.Vector3r(9.87236677 , -279.41862836, -22.81082173) # snow XYZ 0.01 -Z
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)
+
+    def OvercastTeleport(self):
+        position = airsim.Vector3r(213.24547002 , -429.66393833, 19.260)
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)    
+
+    def RainTeleport(self):
+        position = airsim.Vector3r(-315.200 , -444.920, 12.520)
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)
+    
+    def SandTeleport(self):
+        position = airsim.Vector3r(-335.50020795 , 282.16650494, 19.50313758)
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)
+
+    def ClearTeleport(self):
+        position = airsim.Vector3r(-152.28332052 , 236.00371837, 66.40114393)
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)
+
+    def FogTeleport(self):
+        position = airsim.Vector3r(-430.39138328 , -91.7420777, 13.86624983)
+        heading = airsim.utils.to_quaternion(0, 0, 0)
+        pose = airsim.Pose(position, heading)
+        self.client.simSetVehiclePose(pose, True)
+
+
+    def CloseAPI(self):
+        self.client.enableApiControl(False)
+
+    def KeyboardControl(self,x):
+        w = keyboard.KeyboardEvent('down', 150, 'w')             # forward
+        s = keyboard.KeyboardEvent('down', 150, 's')             # back
+        a = keyboard.KeyboardEvent('down', 150, 'a')             # left
+        d = keyboard.KeyboardEvent('down', 150, 'd')             # right
+        up = keyboard.KeyboardEvent('down', 150, 'up')           # up
+        down = keyboard.KeyboardEvent('down', 150, 'down')       # down
+        left = keyboard.KeyboardEvent('down', 150, 'left')       # left
+        right = keyboard.KeyboardEvent('down', 150, 'right')     # right
+        k = keyboard.KeyboardEvent('down', 28, 'k')             # get control
+        l = keyboard.KeyboardEvent('down', 28, 'l')             # release control
+        if x.event_type == 'down' and x.name == w.name:
+            self.client.moveByVelocityBodyFrameAsync(3, 0, 0, 0.5)
+            print("forward")
+        elif x.event_type == 'down' and x.name == s.name:
+            self.client.moveByVelocityBodyFrameAsync(-3, 0, 0, 0.5)
+            print("back")
+        elif x.event_type == 'down' and x.name == a.name:
+            self.client.moveByVelocityBodyFrameAsync(0, -2, 0, 0.5)
+            print("left")
+        elif x.event_type == 'down' and x.name == d.name:
+            self.client.moveByVelocityBodyFrameAsync(0, 2, 0, 0.5)
+            print("right")
+        elif x.event_type == 'down' and x.name == up.name:
+            self.client.moveByVelocityBodyFrameAsync(0, 0, -0.5, 0.5)
+            print("up")
+        elif x.event_type == 'down' and x.name == down.name:
+            self.client.moveByVelocityBodyFrameAsync(0, 0, 0.5, 0.5)
+            print("down")
+        elif x.event_type == 'down' and x.name == left.name:
+            self.client.rotateByYawRateAsync(-20, 0.5)
+            print("turn left")
+        elif x.event_type == 'down' and x.name == right.name:
+            self.client.rotateByYawRateAsync(20, 0.5)
+            print("turn right")
+        elif x.event_type == 'down' and x.name == k.name:
+            # get control
+            self.client.enableApiControl(True)
+            print("get control")
+            # unlock
+            self.client.armDisarm(True)
+            print("unlock")
+            # Async methods returns Future. Call join() to wait for task to complete.
+            self.client.takeoffAsync().join()
+            print("takeoff")
+        elif x.event_type == 'down' and x.name == l.name:
+            keyboard.wait("l")
+            keyboard.unhook_all()
+        else:
+            self.client.moveByVelocityBodyFrameAsync(0, 0, 0, 0.5).join()
+            self.client.hoverAsync().join()
+            print("hovering")
+
+    def ReplayRoute(self):
+        with open('Route.json', 'r', encoding='utf-8') as file:
+            data = json.load(file)
+
+        location_x = data.get("Location.X", [])
+        location_y = data.get("Location.Y", [])
+        location_z = data.get("Location.Z", [])
+
+        # lerp
+        all_frames = set()
+        for arr in [location_x, location_y, location_z]:
+            all_frames.update([item["frame"] for item in arr])
+        all_frames = sorted(all_frames)
+
+        interp_x = interpolate_axis(location_x, all_frames)
+        interp_y = interpolate_axis(location_y, all_frames)
+        interp_z = interpolate_axis(location_z, all_frames)
+
+        for i in range(len(all_frames) - 1):
+            position = airsim.Vector3r(interp_x[i]/100, interp_y[i]/100, -interp_z[i]/100)
+            position_next = airsim.Vector3r(interp_x[i+1]/100, interp_y[i+1]/100, -interp_z[i+1]/100)
+            time = (all_frames[i+1] - all_frames[i]) / 30  # 30 FPS
+            speed = Calc_distance(position, position_next) / time if time > 0 else 1
+            print(position)
+            self.client.moveToPositionAsync(position.x_val, position.y_val, position.z_val, speed).join()
+
+
+def interpolate_axis(axis_list, target_frames):
+    if not axis_list:
+        return [0.0] * len(target_frames)
+    axis_list = sorted(axis_list, key=lambda x: x["frame"])
+    frames = [item["frame"] for item in axis_list]
+    values = [item["value"] for item in axis_list]
+    result = []
+    for f in target_frames:
+        if f <= frames[0]:
+            result.append(values[0])
+        elif f >= frames[-1]:
+            result.append(values[-1])
+        else:
+            for i in range(len(frames) - 1):
+                if frames[i] <= f <= frames[i+1]:
+                    t = (f - frames[i]) / (frames[i+1] - frames[i])
+                    v = values[i] + t * (values[i+1] - values[i])
+                    result.append(v)
+                    break
+    return result
+
+
+def Calc_distance(pos1, pos2):
+    return math.sqrt((pos1.x_val - pos2.x_val) ** 2 + (pos1.y_val - pos2.y_val) ** 2 + (pos1.z_val - pos2.z_val) ** 2)
+
+if __name__ == '__main__':
+    dronne = Drone()
+    # add sleep to make sure excute at same time
+    dronne.ReplayRoute()
+
+dronecontrol = Drone()
+

AirDrone/FileConverter.py

@@ -0,0 +1,27 @@
+from PIL import Image
+import os
+
+def batch_convert_images(input_dir, output_dir):
+    # Create the output directory if it doesn't exist
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # Process each file in the input directory
+    for filename in os.listdir(input_dir):
+        # Check for .ppm or .pgm files (case-insensitive)
+        if filename.lower().endswith('.ppm') or filename.lower().endswith('.pgm'):
+            img_path = os.path.join(input_dir, filename)
+            img = Image.open(img_path)
+
+            # Create the new filename with .png extension
+            new_filename = os.path.splitext(filename)[0] + '.png'
+            save_path = os.path.join(output_dir, new_filename)
+
+            # Save the image as .png
+            img.save(save_path)
+            print(f"Converted: {filename} -> {new_filename}")
+
+# Example usage
+input_dir = 'E:/THU_Projects/DataSets/2025-03-22-20-29-50/images'
+output_dir = 'E:/THU_Projects/DataSets/2025-03-22-20-29-50/PNG'
+batch_convert_images(input_dir, output_dir)

AirDrone/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

AirDrone/SeqOutputer.py

@@ -0,0 +1,53 @@
+# Import built-in modules
+from collections import defaultdict
+import json
+import os
+
+# Import local modules
+import unreal
+
+DIR = os.path.dirname(os.path.abspath(__file__))
+
+def unreal_progress(tasks, label="����", total=None):
+    total = total if total else len(tasks)
+    with unreal.ScopedSlowTask(total, label) as task:
+        task.make_dialog(True)
+        for i, item in enumerate(tasks):
+            if task.should_cancel():
+                break
+            task.enter_progress_frame(1, "%s %s/%s" % (label, i, total))
+            yield item
+
+
+def main():
+    # NOTE: ��ȡ sequence
+    sequence = unreal.load_asset('/Game/RecSeq')
+    # NOTE: �ռ� sequence �������е� binding
+    binding_dict = defaultdict(list)
+    for binding in sequence.get_bindings():
+        binding_dict[binding.get_name()].append(binding)
+
+    # NOTE: ��������Ϊ Face �� binding
+    for binding in unreal_progress(binding_dict.get("BP_FlyingPawn", []), "Transform"):
+        # NOTE: ��ȡ�ؼ�֡ channel ����
+        keys_dict = {}
+        for track in binding.get_tracks():
+            for section in track.get_sections():
+                for channel in unreal_progress(section.get_channels(), "KeyFrame"):
+                    if not channel.get_num_keys():
+                        continue
+                    keys = []
+                    for key in channel.get_keys():
+                        frame_time = key.get_time()
+                        frame = frame_time.frame_number.value + frame_time.sub_frame
+                        keys.append({"frame": frame, "value": key.get_value()})
+
+                    keys_dict[channel.get_name()] = keys
+
+        # NOTE: ���� json
+        name = binding.get_parent().get_name()
+        export_path = os.path.join(DIR, "{0}.json".format(name))
+        with open(export_path, "w") as wf:
+            json.dump(keys_dict, wf, indent=4)
+        
+main()

AirDrone/airsim/__init__.py

@@ -0,0 +1,5 @@
+from .client import *
+from .utils import *
+from .types import *
+
+__version__ = "1.7.0"

AirDrone/airsim/client.py

@@ -0,0 +1,1621 @@
+from __future__ import print_function
+
+from .utils import *
+from .types import *
+
+import msgpackrpc #install as admin: pip install msgpack-rpc-python
+import numpy as np #pip install numpy
+import msgpack
+import time
+import math
+import logging
+
+class VehicleClient:
+    def __init__(self, ip = "", port = 41451, timeout_value = 3600):
+        if (ip == ""):
+            ip = "127.0.0.1"
+        self.client = msgpackrpc.Client(msgpackrpc.Address(ip, port), timeout = timeout_value, pack_encoding = 'utf-8', unpack_encoding = 'utf-8')
+
+#----------------------------------- Common vehicle APIs ---------------------------------------------
+    def reset(self):
+        """
+        Reset the vehicle to its original starting state
+
+        Note that you must call `enableApiControl` and `armDisarm` again after the call to reset
+        """
+        self.client.call('reset')
+
+    def ping(self):
+        """
+        If connection is established then this call will return true otherwise it will be blocked until timeout
+
+        Returns:
+            bool:
+        """
+        return self.client.call('ping')
+
+    def getClientVersion(self):
+        return 1 # sync with C++ client
+
+    def getServerVersion(self):
+        return self.client.call('getServerVersion')
+
+    def getMinRequiredServerVersion(self):
+        return 1 # sync with C++ client
+
+    def getMinRequiredClientVersion(self):
+        return self.client.call('getMinRequiredClientVersion')
+
+#basic flight control
+    def enableApiControl(self, is_enabled, vehicle_name = ''):
+        """
+        Enables or disables API control for vehicle corresponding to vehicle_name
+
+        Args:
+            is_enabled (bool): True to enable, False to disable API control
+            vehicle_name (str, optional): Name of the vehicle to send this command to
+        """
+        self.client.call('enableApiControl', is_enabled, vehicle_name)
+
+    def isApiControlEnabled(self, vehicle_name = ''):
+        """
+        Returns true if API control is established.
+
+        If false (which is default) then API calls would be ignored. After a successful call to `enableApiControl`, `isApiControlEnabled` should return true.
+
+        Args:
+            vehicle_name (str, optional): Name of the vehicle
+
+        Returns:
+            bool: If API control is enabled
+        """
+        return self.client.call('isApiControlEnabled', vehicle_name)
+
+    def armDisarm(self, arm, vehicle_name = ''):
+        """
+        Arms or disarms vehicle
+
+        Args:
+            arm (bool): True to arm, False to disarm the vehicle
+            vehicle_name (str, optional): Name of the vehicle to send this command to
+
+        Returns:
+            bool: Success
+        """
+        return self.client.call('armDisarm', arm, vehicle_name)
+
+    def simPause(self, is_paused):
+        """
+        Pauses simulation
+
+        Args:
+            is_paused (bool): True to pause the simulation, False to release
+        """
+        self.client.call('simPause', is_paused)
+
+    def simIsPause(self):
+        """
+        Returns true if the simulation is paused
+
+        Returns:
+            bool: If the simulation is paused
+        """
+        return self.client.call("simIsPaused")
+
+    def simContinueForTime(self, seconds):
+        """
+        Continue the simulation for the specified number of seconds
+
+        Args:
+            seconds (float): Time to run the simulation for
+        """
+        self.client.call('simContinueForTime', seconds)
+
+    def simContinueForFrames(self, frames):
+        """
+        Continue (or resume if paused) the simulation for the specified number of frames, after which the simulation will be paused.
+
+        Args:
+            frames (int): Frames to run the simulation for
+        """
+        self.client.call('simContinueForFrames', frames)
+
+    def getHomeGeoPoint(self, vehicle_name = ''):
+        """
+        Get the Home location of the vehicle
+
+        Args:
+            vehicle_name (str, optional): Name of vehicle to get home location of
+
+        Returns:
+            GeoPoint: Home location of the vehicle
+        """
+        return GeoPoint.from_msgpack(self.client.call('getHomeGeoPoint', vehicle_name))
+
+    def confirmConnection(self):
+        """
+        Checks state of connection every 1 sec and reports it in Console so user can see the progress for connection.
+        """
+        if self.ping():
+            print("Connected!")
+        else:
+             print("Ping returned false!")
+        server_ver = self.getServerVersion()
+        client_ver = self.getClientVersion()
+        server_min_ver = self.getMinRequiredServerVersion()
+        client_min_ver = self.getMinRequiredClientVersion()
+
+        ver_info = "Client Ver:" + str(client_ver) + " (Min Req: " + str(client_min_ver) + \
+              "), Server Ver:" + str(server_ver) + " (Min Req: " + str(server_min_ver) + ")"
+
+        if server_ver < server_min_ver:
+            print(ver_info, file=sys.stderr)
+            print("AirSim server is of older version and not supported by this client. Please upgrade!")
+        elif client_ver < client_min_ver:
+            print(ver_info, file=sys.stderr)
+            print("AirSim client is of older version and not supported by this server. Please upgrade!")
+        else:
+            print(ver_info)
+        print('')
+
+    def simSetLightIntensity(self, light_name, intensity):
+        """
+        Change intensity of named light
+
+        Args:
+            light_name (str): Name of light to change
+            intensity (float): New intensity value
+
+        Returns:
+            bool: True if successful, otherwise False
+        """
+        return self.client.call("simSetLightIntensity", light_name, intensity)
+
+    def simSwapTextures(self, tags, tex_id = 0, component_id = 0, material_id = 0):
+        """
+        Runtime Swap Texture API
+
+        See https://microsoft.github.io/AirSim/retexturing/ for details
+
+        Args:
+            tags (str): string of "," or ", " delimited tags to identify on which actors to perform the swap
+            tex_id (int, optional): indexes the array of textures assigned to each actor undergoing a swap
+
+                                    If out-of-bounds for some object's texture set, it will be taken modulo the number of textures that were available
+            component_id (int, optional):
+            material_id (int, optional):
+
+        Returns:
+            list[str]: List of objects which matched the provided tags and had the texture swap perfomed
+        """
+        return self.client.call("simSwapTextures", tags, tex_id, component_id, material_id)
+
+    def simSetObjectMaterial(self, object_name, material_name, component_id = 0):
+        """
+        Runtime Swap Texture API
+        See https://microsoft.github.io/AirSim/retexturing/ for details
+        Args:
+            object_name (str): name of object to set material for
+            material_name (str): name of material to set for object
+            component_id (int, optional) : index of material elements
+
+        Returns:
+            bool: True if material was set
+        """
+        return self.client.call("simSetObjectMaterial", object_name, material_name, component_id)
+
+    def simSetObjectMaterialFromTexture(self, object_name, texture_path, component_id = 0):
+        """
+        Runtime Swap Texture API
+        See https://microsoft.github.io/AirSim/retexturing/ for details
+        Args:
+            object_name (str): name of object to set material for
+            texture_path (str): path to texture to set for object
+            component_id (int, optional) : index of material elements
+
+        Returns:
+            bool: True if material was set
+        """
+        return self.client.call("simSetObjectMaterialFromTexture", object_name, texture_path, component_id)
+
+
+    # time-of-day control
+#time - of - day control
+    def simSetTimeOfDay(self, is_enabled, start_datetime = "", is_start_datetime_dst = False, celestial_clock_speed = 1, update_interval_secs = 60, move_sun = True):
+        """
+        Control the position of Sun in the environment
+
+        Sun's position is computed using the coordinates specified in `OriginGeopoint` in settings for the date-time specified in the argument,
+        else if the string is empty, current date & time is used
+
+        Args:
+            is_enabled (bool): True to enable time-of-day effect, False to reset the position to original
+            start_datetime (str, optional): Date & Time in %Y-%m-%d %H:%M:%S format, e.g. `2018-02-12 15:20:00`
+            is_start_datetime_dst (bool, optional): True to adjust for Daylight Savings Time
+            celestial_clock_speed (float, optional): Run celestial clock faster or slower than simulation clock
+                                                     E.g. Value 100 means for every 1 second of simulation clock, Sun's position is advanced by 100 seconds
+                                                     so Sun will move in sky much faster
+            update_interval_secs (float, optional): Interval to update the Sun's position
+            move_sun (bool, optional): Whether or not to move the Sun
+        """
+        self.client.call('simSetTimeOfDay', is_enabled, start_datetime, is_start_datetime_dst, celestial_clock_speed, update_interval_secs, move_sun)
+
+#weather
+    def simEnableWeather(self, enable):
+        """
+        Enable Weather effects. Needs to be called before using `simSetWeatherParameter` API
+
+        Args:
+            enable (bool): True to enable, False to disable
+        """
+        self.client.call('simEnableWeather', enable)
+
+    def simSetWeatherParameter(self, param, val):
+        """
+        Enable various weather effects
+
+        Args:
+            param (WeatherParameter): Weather effect to be enabled
+            val (float): Intensity of the effect, Range 0-1
+        """
+        self.client.call('simSetWeatherParameter', param, val)
+
+#camera control
+#simGetImage returns compressed png in array of bytes
+#image_type uses one of the ImageType members
+    def simGetImage(self, camera_name, image_type, vehicle_name = '', external = False):
+        """
+        Get a single image
+
+        Returns bytes of png format image which can be dumped into abinary file to create .png image
+        `string_to_uint8_array()` can be used to convert into Numpy unit8 array
+        See https://microsoft.github.io/AirSim/image_apis/ for details
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            image_type (ImageType): Type of image required
+            vehicle_name (str, optional): Name of the vehicle with the camera
+            external (bool, optional): Whether the camera is an External Camera
+
+        Returns:
+            Binary string literal of compressed png image
+        """
+#todo : in future remove below, it's only for compatibility to pre v1.2
+        camera_name = str(camera_name)
+
+#because this method returns std::vector < uint8>, msgpack decides to encode it as a string unfortunately.
+        result = self.client.call('simGetImage', camera_name, image_type, vehicle_name, external)
+        if (result == "" or result == "\0"):
+            return None
+        return result
+
+#camera control
+#simGetImage returns compressed png in array of bytes
+#image_type uses one of the ImageType members
+    def simGetImages(self, requests, vehicle_name = '', external = False):
+        """
+        Get multiple images
+
+        See https://microsoft.github.io/AirSim/image_apis/ for details and examples
+
+        Args:
+            requests (list[ImageRequest]): Images required
+            vehicle_name (str, optional): Name of vehicle associated with the camera
+            external (bool, optional): Whether the camera is an External Camera
+
+        Returns:
+            list[ImageResponse]:
+        """
+        responses_raw = self.client.call('simGetImages', requests, vehicle_name, external)
+        return [ImageResponse.from_msgpack(response_raw) for response_raw in responses_raw]
+
+
+
+#CinemAirSim
+    def simGetPresetLensSettings(self, camera_name, vehicle_name = '', external = False):  
+        result = self.client.call('simGetPresetLensSettings', camera_name, vehicle_name, external)
+        if (result == "" or result == "\0"):
+            return None
+        return result
+
+    def simGetLensSettings(self, camera_name, vehicle_name = '', external = False):  
+        result = self.client.call('simGetLensSettings', camera_name, vehicle_name, external)
+        if (result == "" or result == "\0"):
+            return None
+        return result
+
+    def simSetPresetLensSettings(self, preset_lens_settings, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simSetPresetLensSettings", preset_lens_settings, camera_name, vehicle_name, external)
+
+    def simGetPresetFilmbackSettings(self, camera_name, vehicle_name = '', external = False):  
+        result = self.client.call('simGetPresetFilmbackSettings', camera_name, vehicle_name, external)
+        if (result == "" or result == "\0"):
+            return None
+        return result
+
+    def simSetPresetFilmbackSettings(self, preset_filmback_settings, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simSetPresetFilmbackSettings", preset_filmback_settings, camera_name, vehicle_name, external)
+
+    def simGetFilmbackSettings(self, camera_name, vehicle_name = '', external = False):  
+        result = self.client.call('simGetFilmbackSettings', camera_name, vehicle_name, external)
+        if (result == "" or result == "\0"):
+            return None
+        return result
+
+    def simSetFilmbackSettings(self, sensor_width, sensor_height, camera_name, vehicle_name = '', external = False):  
+        return self.client.call("simSetFilmbackSettings", sensor_width, sensor_height, camera_name, vehicle_name, external)
+
+    def simGetFocalLength(self, camera_name, vehicle_name = '', external = False):  
+        return self.client.call("simGetFocalLength", camera_name, vehicle_name, external)
+
+    def simSetFocalLength(self, focal_length, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simSetFocalLength", focal_length, camera_name, vehicle_name, external)
+
+    def simEnableManualFocus(self, enable, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simEnableManualFocus", enable, camera_name, vehicle_name, external)
+
+    def simGetFocusDistance(self, camera_name, vehicle_name = '', external = False):  
+        return self.client.call("simGetFocusDistance", camera_name, vehicle_name, external)
+
+    def simSetFocusDistance(self, focus_distance, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simSetFocusDistance", focus_distance, camera_name, vehicle_name, external)
+
+    def simGetFocusAperture(self, camera_name, vehicle_name = '', external = False):  
+        return self.client.call("simGetFocusAperture", camera_name, vehicle_name, external)
+
+    def simSetFocusAperture(self, focus_aperture, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simSetFocusAperture", focus_aperture, camera_name, vehicle_name, external)
+
+    def simEnableFocusPlane(self, enable, camera_name, vehicle_name = '', external = False):  
+        self.client.call("simEnableFocusPlane", enable, camera_name, vehicle_name, external)
+
+    def simGetCurrentFieldOfView(self, camera_name, vehicle_name = '', external = False):  
+        return self.client.call("simGetCurrentFieldOfView", camera_name, vehicle_name, external)
+
+#End CinemAirSim     
+    def simTestLineOfSightToPoint(self, point, vehicle_name = ''):
+        """
+        Returns whether the target point is visible from the perspective of the inputted vehicle
+
+        Args:
+            point (GeoPoint): target point
+            vehicle_name (str, optional): Name of vehicle
+
+        Returns:
+            [bool]: Success
+        """
+        return self.client.call('simTestLineOfSightToPoint', point, vehicle_name)
+
+    def simTestLineOfSightBetweenPoints(self, point1, point2):
+        """
+        Returns whether the target point is visible from the perspective of the source point
+
+        Args:
+            point1 (GeoPoint): source point
+            point2 (GeoPoint): target point
+
+        Returns:
+            [bool]: Success
+        """
+        return self.client.call('simTestLineOfSightBetweenPoints', point1, point2)
+
+    def simGetWorldExtents(self):
+        """
+        Returns a list of GeoPoints representing the minimum and maximum extents of the world
+
+        Returns:
+            list[GeoPoint]
+        """
+        responses_raw = self.client.call('simGetWorldExtents')
+        return [GeoPoint.from_msgpack(response_raw) for response_raw in responses_raw]
+
+    def simRunConsoleCommand(self, command):
+        """
+        Allows the client to execute a command in Unreal's native console, via an API.
+        Affords access to the countless built-in commands such as "stat unit", "stat fps", "open [map]", adjust any config settings, etc. etc.
+        Allows the user to create bespoke APIs very easily, by adding a custom event to the level blueprint, and then calling the console command "ce MyEventName [args]". No recompilation of AirSim needed!
+
+        Args:
+            command ([string]): Desired Unreal Engine Console command to run
+
+        Returns:
+            [bool]: Success
+        """
+        return self.client.call('simRunConsoleCommand', command)
+
+#gets the static meshes in the unreal scene
+    def simGetMeshPositionVertexBuffers(self):
+        """
+        Returns the static meshes that make up the scene
+
+        See https://microsoft.github.io/AirSim/meshes/ for details and how to use this
+
+        Returns:
+            list[MeshPositionVertexBuffersResponse]:
+        """
+        responses_raw = self.client.call('simGetMeshPositionVertexBuffers')
+        return [MeshPositionVertexBuffersResponse.from_msgpack(response_raw) for response_raw in responses_raw]
+
+    def simGetCollisionInfo(self, vehicle_name = ''):
+        """
+        Args:
+            vehicle_name (str, optional): Name of the Vehicle to get the info of
+
+        Returns:
+            CollisionInfo:
+        """
+        return CollisionInfo.from_msgpack(self.client.call('simGetCollisionInfo', vehicle_name))
+
+    def simSetVehiclePose(self, pose, ignore_collision, vehicle_name = ''):
+        """
+        Set the pose of the vehicle
+
+        If you don't want to change position (or orientation) then just set components of position (or orientation) to floating point nan values
+
+        Args:
+            pose (Pose): Desired Pose pf the vehicle
+            ignore_collision (bool): Whether to ignore any collision or not
+            vehicle_name (str, optional): Name of the vehicle to move
+        """
+        self.client.call('simSetVehiclePose', pose, ignore_collision, vehicle_name)
+
+    def simGetVehiclePose(self, vehicle_name = ''):
+        """
+        The position inside the returned Pose is in the frame of the vehicle's starting point
+        
+        Args:
+            vehicle_name (str, optional): Name of the vehicle to get the Pose of
+
+        Returns:
+            Pose:
+        """
+        pose = self.client.call('simGetVehiclePose', vehicle_name)
+        return Pose.from_msgpack(pose)
+
+    def simSetTraceLine(self, color_rgba, thickness=1.0, vehicle_name = ''):
+        """
+        Modify the color and thickness of the line when Tracing is enabled
+
+        Tracing can be enabled by pressing T in the Editor or setting `EnableTrace` to `True` in the Vehicle Settings
+
+        Args:
+            color_rgba (list): desired RGBA values from 0.0 to 1.0
+            thickness (float, optional): Thickness of the line
+            vehicle_name (string, optional): Name of the vehicle to set Trace line values for
+        """
+        self.client.call('simSetTraceLine', color_rgba, thickness, vehicle_name)
+
+    def simGetObjectPose(self, object_name):
+        """
+        The position inside the returned Pose is in the world frame
+
+        Args:
+            object_name (str): Object to get the Pose of
+
+        Returns:
+            Pose:
+        """
+        pose = self.client.call('simGetObjectPose', object_name)
+        return Pose.from_msgpack(pose)
+
+    def simSetObjectPose(self, object_name, pose, teleport = True):
+        """
+        Set the pose of the object(actor) in the environment
+
+        The specified actor must have Mobility set to movable, otherwise there will be undefined behaviour.
+        See https://www.unrealengine.com/en-US/blog/moving-physical-objects for details on how to set Mobility and the effect of Teleport parameter
+
+        Args:
+            object_name (str): Name of the object(actor) to move
+            pose (Pose): Desired Pose of the object
+            teleport (bool, optional): Whether to move the object immediately without affecting their velocity
+
+        Returns:
+            bool: If the move was successful
+        """
+        return self.client.call('simSetObjectPose', object_name, pose, teleport)
+
+    def simGetObjectScale(self, object_name):
+        """
+        Gets scale of an object in the world
+
+        Args:
+            object_name (str): Object to get the scale of
+
+        Returns:
+            airsim.Vector3r: Scale
+        """
+        scale = self.client.call('simGetObjectScale', object_name)
+        return Vector3r.from_msgpack(scale)
+
+    def simSetObjectScale(self, object_name, scale_vector):
+        """
+        Sets scale of an object in the world
+
+        Args:
+            object_name (str): Object to set the scale of
+            scale_vector (airsim.Vector3r): Desired scale of object
+
+        Returns:
+            bool: True if scale change was successful
+        """
+        return self.client.call('simSetObjectScale', object_name, scale_vector)
+
+    def simListSceneObjects(self, name_regex = '.*'):
+        """
+        Lists the objects present in the environment
+
+        Default behaviour is to list all objects, regex can be used to return smaller list of matching objects or actors
+
+        Args:
+            name_regex (str, optional): String to match actor names against, e.g. "Cylinder.*"
+
+        Returns:
+            list[str]: List containing all the names
+        """
+        return self.client.call('simListSceneObjects', name_regex)
+
+    def simLoadLevel(self, level_name):
+        """
+        Loads a level specified by its name
+
+        Args:
+            level_name (str): Name of the level to load
+
+        Returns:
+            bool: True if the level was successfully loaded
+        """
+        return self.client.call('simLoadLevel', level_name)
+
+    def simListAssets(self):
+        """
+        Lists all the assets present in the Asset Registry
+
+        Returns:
+            list[str]: Names of all the assets
+        """
+        return self.client.call('simListAssets')
+
+    def simSpawnObject(self, object_name, asset_name, pose, scale, physics_enabled=False, is_blueprint=False):
+        """Spawned selected object in the world
+
+        Args:
+            object_name (str): Desired name of new object
+            asset_name (str): Name of asset(mesh) in the project database
+            pose (airsim.Pose): Desired pose of object
+            scale (airsim.Vector3r): Desired scale of object
+            physics_enabled (bool, optional): Whether to enable physics for the object
+            is_blueprint (bool, optional): Whether to spawn a blueprint or an actor
+
+        Returns:
+            str: Name of spawned object, in case it had to be modified
+        """
+        return self.client.call('simSpawnObject', object_name, asset_name, pose, scale, physics_enabled, is_blueprint)
+
+    def simDestroyObject(self, object_name):
+        """Removes selected object from the world
+
+        Args:
+            object_name (str): Name of object to be removed
+
+        Returns:
+            bool: True if object is queued up for removal
+        """
+        return self.client.call('simDestroyObject', object_name)
+
+    def simSetSegmentationObjectID(self, mesh_name, object_id, is_name_regex = False):
+        """
+        Set segmentation ID for specific objects
+
+        See https://microsoft.github.io/AirSim/image_apis/#segmentation for details
+
+        Args:
+            mesh_name (str): Name of the mesh to set the ID of (supports regex)
+            object_id (int): Object ID to be set, range 0-255
+
+                             RBG values for IDs can be seen at https://microsoft.github.io/AirSim/seg_rgbs.txt
+            is_name_regex (bool, optional): Whether the mesh name is a regex
+
+        Returns:
+            bool: If the mesh was found
+        """
+        return self.client.call('simSetSegmentationObjectID', mesh_name, object_id, is_name_regex)
+
+    def simGetSegmentationObjectID(self, mesh_name):
+        """
+        Returns Object ID for the given mesh name
+
+        Mapping of Object IDs to RGB values can be seen at https://microsoft.github.io/AirSim/seg_rgbs.txt
+
+        Args:
+            mesh_name (str): Name of the mesh to get the ID of
+        """
+        return self.client.call('simGetSegmentationObjectID', mesh_name)
+
+    def simAddDetectionFilterMeshName(self, camera_name, image_type, mesh_name, vehicle_name = '', external = False):
+        """
+        Add mesh name to detect in wild card format
+
+        For example: simAddDetectionFilterMeshName("Car_*") will detect all instance named "Car_*"
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            image_type (ImageType): Type of image required
+            mesh_name (str): mesh name in wild card format
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+
+        """
+        self.client.call('simAddDetectionFilterMeshName', camera_name, image_type, mesh_name, vehicle_name, external)
+
+    def simSetDetectionFilterRadius(self, camera_name, image_type, radius_cm, vehicle_name = '', external = False):
+        """
+        Set detection radius for all cameras
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            image_type (ImageType): Type of image required
+            radius_cm (int): Radius in [cm]
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+        """
+        self.client.call('simSetDetectionFilterRadius', camera_name, image_type, radius_cm, vehicle_name, external)
+
+    def simClearDetectionMeshNames(self, camera_name, image_type, vehicle_name = '', external = False):
+        """
+        Clear all mesh names from detection filter
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            image_type (ImageType): Type of image required
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+
+        """
+        self.client.call('simClearDetectionMeshNames', camera_name, image_type, vehicle_name, external)
+
+    def simGetDetections(self, camera_name, image_type, vehicle_name = '', external = False):
+        """
+        Get current detections
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            image_type (ImageType): Type of image required
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+
+        Returns:
+            DetectionInfo array
+        """
+        responses_raw = self.client.call('simGetDetections', camera_name, image_type, vehicle_name, external)
+        return [DetectionInfo.from_msgpack(response_raw) for response_raw in responses_raw]
+
+    def simPrintLogMessage(self, message, message_param = "", severity = 0):
+        """
+        Prints the specified message in the simulator's window.
+
+        If message_param is supplied, then it's printed next to the message and in that case if this API is called with same message value
+        but different message_param again then previous line is overwritten with new line (instead of API creating new line on display).
+
+        For example, `simPrintLogMessage("Iteration: ", to_string(i))` keeps updating same line on display when API is called with different values of i.
+        The valid values of severity parameter is 0 to 3 inclusive that corresponds to different colors.
+
+        Args:
+            message (str): Message to be printed
+            message_param (str, optional): Parameter to be printed next to the message
+            severity (int, optional): Range 0-3, inclusive, corresponding to the severity of the message
+        """
+        self.client.call('simPrintLogMessage', message, message_param, severity)
+
+    def simGetCameraInfo(self, camera_name, vehicle_name = '', external=False):
+        """
+        Get details about the camera
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+
+        Returns:
+            CameraInfo:
+        """
+#TODO : below str() conversion is only needed for legacy reason and should be removed in future
+        return CameraInfo.from_msgpack(self.client.call('simGetCameraInfo', str(camera_name), vehicle_name, external))
+
+    def simGetDistortionParams(self, camera_name, vehicle_name = '', external = False):
+        """
+        Get camera distortion parameters
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+
+        Returns:
+            List (float): List of distortion parameter values corresponding to K1, K2, K3, P1, P2 respectively.
+        """
+
+        return self.client.call('simGetDistortionParams', str(camera_name), vehicle_name, external)
+
+    def simSetDistortionParams(self, camera_name, distortion_params, vehicle_name = '', external = False):
+        """
+        Set camera distortion parameters
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            distortion_params (dict): Dictionary of distortion param names and corresponding values
+                                        {"K1": 0.0, "K2": 0.0, "K3": 0.0, "P1": 0.0, "P2": 0.0}
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+        """
+
+        for param_name, value in distortion_params.items():
+            self.simSetDistortionParam(camera_name, param_name, value, vehicle_name, external)
+
+    def simSetDistortionParam(self, camera_name, param_name, value, vehicle_name = '', external = False):
+        """
+        Set single camera distortion parameter
+
+        Args:
+            camera_name (str): Name of the camera, for backwards compatibility, ID numbers such as 0,1,etc. can also be used
+            param_name (str): Name of distortion parameter
+            value (float): Value of distortion parameter
+            vehicle_name (str, optional): Vehicle which the camera is associated with
+            external (bool, optional): Whether the camera is an External Camera
+        """
+        self.client.call('simSetDistortionParam', str(camera_name), param_name, value, vehicle_name, external)
+
+    def simSetCameraPose(self, camera_name, pose, vehicle_name = '', external = False):
+        """
+        - Control the pose of a selected camera
+
+        Args:
+            camera_name (str): Name of the camera to be controlled
+            pose (Pose): Pose representing the desired position and orientation of the camera
+            vehicle_name (str, optional): Name of vehicle which the camera corresponds to
+            external (bool, optional): Whether the camera is an External Camera
+        """
+#TODO : below str() conversion is only needed for legacy reason and should be removed in future
+        self.client.call('simSetCameraPose', str(camera_name), pose, vehicle_name, external)
+
+    def simSetCameraFov(self, camera_name, fov_degrees, vehicle_name = '', external = False):
+        """
+        - Control the field of view of a selected camera
+
+        Args:
+            camera_name (str): Name of the camera to be controlled
+            fov_degrees (float): Value of field of view in degrees
+            vehicle_name (str, optional): Name of vehicle which the camera corresponds to
+            external (bool, optional): Whether the camera is an External Camera
+        """
+#TODO : below str() conversion is only needed for legacy reason and should be removed in future
+        self.client.call('simSetCameraFov', str(camera_name), fov_degrees, vehicle_name, external)
+
+    def simGetGroundTruthKinematics(self, vehicle_name = ''):
+        """
+        Get Ground truth kinematics of the vehicle
+
+        The position inside the returned KinematicsState is in the frame of the vehicle's starting point
+
+        Args:
+            vehicle_name (str, optional): Name of the vehicle
+
+        Returns:
+            KinematicsState: Ground truth of the vehicle
+        """
+        kinematics_state = self.client.call('simGetGroundTruthKinematics', vehicle_name)
+        return KinematicsState.from_msgpack(kinematics_state)
+    simGetGroundTruthKinematics.__annotations__ = {'return': KinematicsState}
+
+    def simSetKinematics(self, state, ignore_collision, vehicle_name = ''):
+        """
+        Set the kinematics state of the vehicle
+
+        If you don't want to change position (or orientation) then just set components of position (or orientation) to floating point nan values
+
+        Args:
+            state (KinematicsState): Desired Pose pf the vehicle
+            ignore_collision (bool): Whether to ignore any collision or not
+            vehicle_name (str, optional): Name of the vehicle to move
+        """
+        self.client.call('simSetKinematics', state, ignore_collision, vehicle_name)
+
+    def simGetGroundTruthEnvironment(self, vehicle_name = ''):
+        """
+        Get ground truth environment state
+
+        The position inside the returned EnvironmentState is in the frame of the vehicle's starting point
+
+        Args:
+            vehicle_name (str, optional): Name of the vehicle
+
+        Returns:
+            EnvironmentState: Ground truth environment state
+        """
+        env_state = self.client.call('simGetGroundTruthEnvironment', vehicle_name)
+        return EnvironmentState.from_msgpack(env_state)
+    simGetGroundTruthEnvironment.__annotations__ = {'return': EnvironmentState}
+
+
+#sensor APIs
+    def getImuData(self, imu_name = '', vehicle_name = ''):
+        """
+        Args:
+            imu_name (str, optional): Name of IMU to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            ImuData:
+        """
+        return ImuData.from_msgpack(self.client.call('getImuData', imu_name, vehicle_name))
+
+    def getBarometerData(self, barometer_name = '', vehicle_name = ''):
+        """
+        Args:
+            barometer_name (str, optional): Name of Barometer to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            BarometerData:
+        """
+        return BarometerData.from_msgpack(self.client.call('getBarometerData', barometer_name, vehicle_name))
+
+    def getMagnetometerData(self, magnetometer_name = '', vehicle_name = ''):
+        """
+        Args:
+            magnetometer_name (str, optional): Name of Magnetometer to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            MagnetometerData:
+        """
+        return MagnetometerData.from_msgpack(self.client.call('getMagnetometerData', magnetometer_name, vehicle_name))
+
+    def getGpsData(self, gps_name = '', vehicle_name = ''):
+        """
+        Args:
+            gps_name (str, optional): Name of GPS to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            GpsData:
+        """
+        return GpsData.from_msgpack(self.client.call('getGpsData', gps_name, vehicle_name))
+
+    def getDistanceSensorData(self, distance_sensor_name = '', vehicle_name = ''):
+        """
+        Args:
+            distance_sensor_name (str, optional): Name of Distance Sensor to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            DistanceSensorData:
+        """
+        return DistanceSensorData.from_msgpack(self.client.call('getDistanceSensorData', distance_sensor_name, vehicle_name))
+
+    def getLidarData(self, lidar_name = '', vehicle_name = ''):
+        """
+        Args:
+            lidar_name (str, optional): Name of Lidar to get data from, specified in settings.json
+            vehicle_name (str, optional): Name of vehicle to which the sensor corresponds to
+
+        Returns:
+            LidarData:
+        """
+        return LidarData.from_msgpack(self.client.call('getLidarData', lidar_name, vehicle_name))
+
+    def simGetLidarSegmentation(self, lidar_name = '', vehicle_name = ''):
+        """
+        NOTE: Deprecated API, use `getLidarData()` API instead
+        Returns Segmentation ID of each point's collided object in the last Lidar update
+
+        Args:
+            lidar_name (str, optional): Name of Lidar sensor
+            vehicle_name (str, optional): Name of the vehicle wth the sensor
+
+        Returns:
+            list[int]: Segmentation IDs of the objects
+        """
+        logging.warning("simGetLidarSegmentation API is deprecated, use getLidarData() API instead")
+        return self.getLidarData(lidar_name, vehicle_name).segmentation
+
+#Plotting APIs
+    def simFlushPersistentMarkers(self):
+        """
+        Clear any persistent markers - those plotted with setting `is_persistent=True` in the APIs below
+        """
+        self.client.call('simFlushPersistentMarkers')
+
+    def simPlotPoints(self, points, color_rgba=[1.0, 0.0, 0.0, 1.0], size = 10.0, duration = -1.0, is_persistent = False):
+        """
+        Plot a list of 3D points in World NED frame
+
+        Args:
+            points (list[Vector3r]): List of Vector3r objects
+            color_rgba (list, optional): desired RGBA values from 0.0 to 1.0
+            size (float, optional): Size of plotted point
+            duration (float, optional): Duration (seconds) to plot for
+            is_persistent (bool, optional): If set to True, the desired object will be plotted for infinite time.
+        """
+        self.client.call('simPlotPoints', points, color_rgba, size, duration, is_persistent)
+
+    def simPlotLineStrip(self, points, color_rgba=[1.0, 0.0, 0.0, 1.0], thickness = 5.0, duration = -1.0, is_persistent = False):
+        """
+        Plots a line strip in World NED frame, defined from points[0] to points[1], points[1] to points[2], ... , points[n-2] to points[n-1]
+
+        Args:
+            points (list[Vector3r]): List of 3D locations of line start and end points, specified as Vector3r objects
+            color_rgba (list, optional): desired RGBA values from 0.0 to 1.0
+            thickness (float, optional): Thickness of line
+            duration (float, optional): Duration (seconds) to plot for
+            is_persistent (bool, optional): If set to True, the desired object will be plotted for infinite time.
+        """
+        self.client.call('simPlotLineStrip', points, color_rgba, thickness, duration, is_persistent)
+
+    def simPlotLineList(self, points, color_rgba=[1.0, 0.0, 0.0, 1.0], thickness = 5.0, duration = -1.0, is_persistent = False):
+        """
+        Plots a line strip in World NED frame, defined from points[0] to points[1], points[2] to points[3], ... , points[n-2] to points[n-1]
+
+        Args:
+            points (list[Vector3r]): List of 3D locations of line start and end points, specified as Vector3r objects. Must be even
+            color_rgba (list, optional): desired RGBA values from 0.0 to 1.0
+            thickness (float, optional): Thickness of line
+            duration (float, optional): Duration (seconds) to plot for
+            is_persistent (bool, optional): If set to True, the desired object will be plotted for infinite time.
+        """
+        self.client.call('simPlotLineList', points, color_rgba, thickness, duration, is_persistent)
+
+    def simPlotArrows(self, points_start, points_end, color_rgba=[1.0, 0.0, 0.0, 1.0], thickness = 5.0, arrow_size = 2.0, duration = -1.0, is_persistent = False):
+        """
+        Plots a list of arrows in World NED frame, defined from points_start[0] to points_end[0], points_start[1] to points_end[1], ... , points_start[n-1] to points_end[n-1]
+
+        Args:
+            points_start (list[Vector3r]): List of 3D start positions of arrow start positions, specified as Vector3r objects
+            points_end (list[Vector3r]): List of 3D end positions of arrow start positions, specified as Vector3r objects
+            color_rgba (list, optional): desired RGBA values from 0.0 to 1.0
+            thickness (float, optional): Thickness of line
+            arrow_size (float, optional): Size of arrow head
+            duration (float, optional): Duration (seconds) to plot for
+            is_persistent (bool, optional): If set to True, the desired object will be plotted for infinite time.
+        """
+        self.client.call('simPlotArrows', points_start, points_end, color_rgba, thickness, arrow_size, duration, is_persistent)
+
+
+    def simPlotStrings(self, strings, positions, scale = 5, color_rgba=[1.0, 0.0, 0.0, 1.0], duration = -1.0):
+        """
+        Plots a list of strings at desired positions in World NED frame.
+
+        Args:
+            strings (list[String], optional): List of strings to plot
+            positions (list[Vector3r]): List of positions where the strings should be plotted. Should be in one-to-one correspondence with the strings' list
+            scale (float, optional): Font scale of transform name
+            color_rgba (list, optional): desired RGBA values from 0.0 to 1.0
+            duration (float, optional): Duration (seconds) to plot for
+        """
+        self.client.call('simPlotStrings', strings, positions, scale, color_rgba, duration)
+
+    def simPlotTransforms(self, poses, scale = 5.0, thickness = 5.0, duration = -1.0, is_persistent = False):
+        """
+        Plots a list of transforms in World NED frame.
+
+        Args:
+            poses (list[Pose]): List of Pose objects representing the transforms to plot
+            scale (float, optional): Length of transforms' axes
+            thickness (float, optional): Thickness of transforms' axes
+            duration (float, optional): Duration (seconds) to plot for
+            is_persistent (bool, optional): If set to True, the desired object will be plotted for infinite time.
+        """
+        self.client.call('simPlotTransforms', poses, scale, thickness, duration, is_persistent)
+
+    def simPlotTransformsWithNames(self, poses, names, tf_scale = 5.0, tf_thickness = 5.0, text_scale = 10.0, text_color_rgba = [1.0, 0.0, 0.0, 1.0], duration = -1.0):
+        """
+        Plots a list of transforms with their names in World NED frame.
+
+        Args:
+            poses (list[Pose]): List of Pose objects representing the transforms to plot
+            names (list[string]): List of strings with one-to-one correspondence to list of poses
+            tf_scale (float, optional): Length of transforms' axes
+            tf_thickness (float, optional): Thickness of transforms' axes
+            text_scale (float, optional): Font scale of transform name
+            text_color_rgba (list, optional): desired RGBA values from 0.0 to 1.0 for the transform name
+            duration (float, optional): Duration (seconds) to plot for
+        """
+        self.client.call('simPlotTransformsWithNames', poses, names, tf_scale, tf_thickness, text_scale, text_color_rgba, duration)
+
+    def cancelLastTask(self, vehicle_name = ''):
+        """
+        Cancel previous Async task
+
+        Args:
+            vehicle_name (str, optional): Name of the vehicle
+        """
+        self.client.call('cancelLastTask', vehicle_name)
+
+#Recording APIs
+    def startRecording(self):
+        """
+        Start Recording
+
+        Recording will be done according to the settings
+        """
+        self.client.call('startRecording')
+
+    def stopRecording(self):
+        """
+        Stop Recording
+        """
+        self.client.call('stopRecording')
+
+    def isRecording(self):
+        """
+        Whether Recording is running or not
+
+        Returns:
+            bool: True if Recording, else False
+        """
+        return self.client.call('isRecording')
+
+    def simSetWind(self, wind):
+        """
+        Set simulated wind, in World frame, NED direction, m/s
+
+        Args:
+            wind (Vector3r): Wind, in World frame, NED direction, in m/s
+        """
+        self.client.call('simSetWind', wind)
+
+    def simCreateVoxelGrid(self, position, x, y, z, res, of):
+        """
+        Construct and save a binvox-formatted voxel grid of environment
+
+        Args:
+            position (Vector3r): Position around which voxel grid is centered in m
+            x, y, z (int): Size of each voxel grid dimension in m
+            res (float): Resolution of voxel grid in m
+            of (str): Name of output file to save voxel grid as
+
+        Returns:
+            bool: True if output written to file successfully, else False
+        """
+        return self.client.call('simCreateVoxelGrid', position, x, y, z, res, of)
+
+#Add new vehicle via RPC
+    def simAddVehicle(self, vehicle_name, vehicle_type, pose, pawn_path = ""):
+        """
+        Create vehicle at runtime
+
+        Args:
+            vehicle_name (str): Name of the vehicle being created
+            vehicle_type (str): Type of vehicle, e.g. "simpleflight"
+            pose (Pose): Initial pose of the vehicle
+            pawn_path (str, optional): Vehicle blueprint path, default empty wbich uses the default blueprint for the vehicle type
+
+        Returns:
+            bool: Whether vehicle was created
+        """
+        return self.client.call('simAddVehicle', vehicle_name, vehicle_type, pose, pawn_path)
+
+    def listVehicles(self):
+        """
+        Lists the names of current vehicles
+
+        Returns:
+            list[str]: List containing names of all vehicles
+        """
+        return self.client.call('listVehicles')
+
+    def getSettingsString(self):
+        """
+        Fetch the settings text being used by AirSim
+
+        Returns:
+            str: Settings text in JSON format
+        """
+        return self.client.call('getSettingsString')
+
+#----------------------------------- Multirotor APIs ---------------------------------------------
+class MultirotorClient(VehicleClient, object):
+    def __init__(self, ip = "", port = 41451, timeout_value = 3600):
+        super(MultirotorClient, self).__init__(ip, port, timeout_value)
+
+    def takeoffAsync(self, timeout_sec = 20, vehicle_name = ''):
+        """
+        Takeoff vehicle to 3m above ground. Vehicle should not be moving when this API is used
+
+        Args:
+            timeout_sec (int, optional): Timeout for the vehicle to reach desired altitude
+            vehicle_name (str, optional): Name of the vehicle to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('takeoff', timeout_sec, vehicle_name)
+
+    def landAsync(self, timeout_sec = 60, vehicle_name = ''):
+        """
+        Land the vehicle
+
+        Args:
+            timeout_sec (int, optional): Timeout for the vehicle to land
+            vehicle_name (str, optional): Name of the vehicle to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('land', timeout_sec, vehicle_name)
+
+    def goHomeAsync(self, timeout_sec = 3e+38, vehicle_name = ''):
+        """
+        Return vehicle to Home i.e. Launch location
+
+        Args:
+            timeout_sec (int, optional): Timeout for the vehicle to reach desired altitude
+            vehicle_name (str, optional): Name of the vehicle to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('goHome', timeout_sec, vehicle_name)
+
+#APIs for control
+    def moveByVelocityBodyFrameAsync(self, vx, vy, vz, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''):
+        """
+        Args:
+            vx (float): desired velocity in the X axis of the vehicle's local NED frame.
+            vy (float): desired velocity in the Y axis of the vehicle's local NED frame.
+            vz (float): desired velocity in the Z axis of the vehicle's local NED frame.
+            duration (float): Desired amount of time (seconds), to send this command for
+            drivetrain (DrivetrainType, optional):
+            yaw_mode (YawMode, optional):
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByVelocityBodyFrame', vx, vy, vz, duration, drivetrain, yaw_mode, vehicle_name)
+
+    def moveByVelocityZBodyFrameAsync(self, vx, vy, z, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''):
+        """
+        Args:
+            vx (float): desired velocity in the X axis of the vehicle's local NED frame
+            vy (float): desired velocity in the Y axis of the vehicle's local NED frame
+            z (float): desired Z value (in local NED frame of the vehicle)
+            duration (float): Desired amount of time (seconds), to send this command for
+            drivetrain (DrivetrainType, optional):
+            yaw_mode (YawMode, optional):
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+
+        return self.client.call_async('moveByVelocityZBodyFrame', vx, vy, z, duration, drivetrain, yaw_mode, vehicle_name)
+
+    def moveByAngleZAsync(self, pitch, roll, z, yaw, duration, vehicle_name = ''):
+        logging.warning("moveByAngleZAsync API is deprecated, use moveByRollPitchYawZAsync() API instead")
+        return self.client.call_async('moveByRollPitchYawZ', roll, -pitch, -yaw, z, duration, vehicle_name)
+
+    def moveByAngleThrottleAsync(self, pitch, roll, throttle, yaw_rate, duration, vehicle_name = ''):
+        logging.warning("moveByAngleThrottleAsync API is deprecated, use moveByRollPitchYawrateThrottleAsync() API instead")
+        return self.client.call_async('moveByRollPitchYawrateThrottle', roll, -pitch, -yaw_rate, throttle, duration, vehicle_name)
+
+    def moveByVelocityAsync(self, vx, vy, vz, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''):
+        """
+        Args:
+            vx (float): desired velocity in world (NED) X axis
+            vy (float): desired velocity in world (NED) Y axis
+            vz (float): desired velocity in world (NED) Z axis
+            duration (float): Desired amount of time (seconds), to send this command for
+            drivetrain (DrivetrainType, optional):
+            yaw_mode (YawMode, optional):
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByVelocity', vx, vy, vz, duration, drivetrain, yaw_mode, vehicle_name)
+
+    def moveByVelocityZAsync(self, vx, vy, z, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''):
+        return self.client.call_async('moveByVelocityZ', vx, vy, z, duration, drivetrain, yaw_mode, vehicle_name)
+
+    def moveOnPathAsync(self, path, velocity, timeout_sec = 3e+38, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(),
+        lookahead = -1, adaptive_lookahead = 1, vehicle_name = ''):
+        return self.client.call_async('moveOnPath', path, velocity, timeout_sec, drivetrain, yaw_mode, lookahead, adaptive_lookahead, vehicle_name)
+
+    def moveToPositionAsync(self, x, y, z, velocity, timeout_sec = 3e+38, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(),
+        lookahead = -1, adaptive_lookahead = 1, vehicle_name = ''):
+        return self.client.call_async('moveToPosition', x, y, z, velocity, timeout_sec, drivetrain, yaw_mode, lookahead, adaptive_lookahead, vehicle_name)
+
+    def moveToGPSAsync(self, latitude, longitude, altitude, velocity, timeout_sec = 3e+38, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(),
+        lookahead = -1, adaptive_lookahead = 1, vehicle_name = ''):
+        return self.client.call_async('moveToGPS', latitude, longitude, altitude, velocity, timeout_sec, drivetrain, yaw_mode, lookahead, adaptive_lookahead, vehicle_name)
+
+    def moveToZAsync(self, z, velocity, timeout_sec = 3e+38, yaw_mode = YawMode(), lookahead = -1, adaptive_lookahead = 1, vehicle_name = ''):
+        return self.client.call_async('moveToZ', z, velocity, timeout_sec, yaw_mode, lookahead, adaptive_lookahead, vehicle_name)
+
+    def moveByManualAsync(self, vx_max, vy_max, z_min, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''):
+        """
+        - Read current RC state and use it to control the vehicles.
+
+        Parameters sets up the constraints on velocity and minimum altitude while flying. If RC state is detected to violate these constraints
+        then that RC state would be ignored.
+
+        Args:
+            vx_max (float): max velocity allowed in x direction
+            vy_max (float): max velocity allowed in y direction
+            vz_max (float): max velocity allowed in z direction
+            z_min (float): min z allowed for vehicle position
+            duration (float): after this duration vehicle would switch back to non-manual mode
+            drivetrain (DrivetrainType): when ForwardOnly, vehicle rotates itself so that its front is always facing the direction of travel. If MaxDegreeOfFreedom then it doesn't do that (crab-like movement)
+            yaw_mode (YawMode): Specifies if vehicle should face at given angle (is_rate=False) or should be rotating around its axis at given rate (is_rate=True)
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByManual', vx_max, vy_max, z_min, duration, drivetrain, yaw_mode, vehicle_name)
+
+    def rotateToYawAsync(self, yaw, timeout_sec = 3e+38, margin = 5, vehicle_name = ''):
+        return self.client.call_async('rotateToYaw', yaw, timeout_sec, margin, vehicle_name)
+
+    def rotateByYawRateAsync(self, yaw_rate, duration, vehicle_name = ''):
+        return self.client.call_async('rotateByYawRate', yaw_rate, duration, vehicle_name)
+
+    def hoverAsync(self, vehicle_name = ''):
+        return self.client.call_async('hover', vehicle_name)
+
+    def moveByRC(self, rcdata = RCData(), vehicle_name = ''):
+        return self.client.call('moveByRC', rcdata, vehicle_name)
+
+#low - level control API
+    def moveByMotorPWMsAsync(self, front_right_pwm, rear_left_pwm, front_left_pwm, rear_right_pwm, duration, vehicle_name = ''):
+        """
+        - Directly control the motors using PWM values
+
+        Args:
+            front_right_pwm (float): PWM value for the front right motor (between 0.0 to 1.0)
+            rear_left_pwm (float): PWM value for the rear left motor (between 0.0 to 1.0)
+            front_left_pwm (float): PWM value for the front left motor (between 0.0 to 1.0)
+            rear_right_pwm (float): PWM value for the rear right motor (between 0.0 to 1.0)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByMotorPWMs', front_right_pwm, rear_left_pwm, front_left_pwm, rear_right_pwm, duration, vehicle_name)
+
+    def moveByRollPitchYawZAsync(self, roll, pitch, yaw, z, duration, vehicle_name = ''):
+        """
+        - z is given in local NED frame of the vehicle.
+        - Roll angle, pitch angle, and yaw angle set points are given in **radians**, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll (float): Desired roll angle, in radians.
+            pitch (float): Desired pitch angle, in radians.
+            yaw (float): Desired yaw angle, in radians.
+            z (float): Desired Z value (in local NED frame of the vehicle)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByRollPitchYawZ', roll, -pitch, -yaw, z, duration, vehicle_name)
+
+    def moveByRollPitchYawThrottleAsync(self, roll, pitch, yaw, throttle, duration, vehicle_name = ''):
+        """
+        - Desired throttle is between 0.0 to 1.0
+        - Roll angle, pitch angle, and yaw angle are given in **degrees** when using PX4 and in **radians** when using SimpleFlight, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll (float): Desired roll angle.
+            pitch (float): Desired pitch angle.
+            yaw (float): Desired yaw angle.
+            throttle (float): Desired throttle (between 0.0 to 1.0)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByRollPitchYawThrottle', roll, -pitch, -yaw, throttle, duration, vehicle_name)
+
+    def moveByRollPitchYawrateThrottleAsync(self, roll, pitch, yaw_rate, throttle, duration, vehicle_name = ''):
+        """
+        - Desired throttle is between 0.0 to 1.0
+        - Roll angle, pitch angle, and yaw rate set points are given in **radians**, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll (float): Desired roll angle, in radians.
+            pitch (float): Desired pitch angle, in radians.
+            yaw_rate (float): Desired yaw rate, in radian per second.
+            throttle (float): Desired throttle (between 0.0 to 1.0)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByRollPitchYawrateThrottle', roll, -pitch, -yaw_rate, throttle, duration, vehicle_name)
+
+    def moveByRollPitchYawrateZAsync(self, roll, pitch, yaw_rate, z, duration, vehicle_name = ''):
+        """
+        - z is given in local NED frame of the vehicle.
+        - Roll angle, pitch angle, and yaw rate set points are given in **radians**, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll (float): Desired roll angle, in radians.
+            pitch (float): Desired pitch angle, in radians.
+            yaw_rate (float): Desired yaw rate, in radian per second.
+            z (float): Desired Z value (in local NED frame of the vehicle)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByRollPitchYawrateZ', roll, -pitch, -yaw_rate, z, duration, vehicle_name)
+
+    def moveByAngleRatesZAsync(self, roll_rate, pitch_rate, yaw_rate, z, duration, vehicle_name = ''):
+        """
+        - z is given in local NED frame of the vehicle.
+        - Roll rate, pitch rate, and yaw rate set points are given in **radians**, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll_rate (float): Desired roll rate, in radians / second
+            pitch_rate (float): Desired pitch rate, in radians / second
+            yaw_rate (float): Desired yaw rate, in radians / second
+            z (float): Desired Z value (in local NED frame of the vehicle)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByAngleRatesZ', roll_rate, -pitch_rate, -yaw_rate, z, duration, vehicle_name)
+
+    def moveByAngleRatesThrottleAsync(self, roll_rate, pitch_rate, yaw_rate, throttle, duration, vehicle_name = ''):
+        """
+        - Desired throttle is between 0.0 to 1.0
+        - Roll rate, pitch rate, and yaw rate set points are given in **radians**, in the body frame.
+        - The body frame follows the Front Left Up (FLU) convention, and right-handedness.
+
+        - Frame Convention:
+            - X axis is along the **Front** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **roll** angle.
+            | Hence, rolling with a positive angle is equivalent to translating in the **right** direction, w.r.t. our FLU body frame.
+
+            - Y axis is along the **Left** direction of the quadrotor.
+
+            | Clockwise rotation about this axis defines a positive **pitch** angle.
+            | Hence, pitching with a positive angle is equivalent to translating in the **front** direction, w.r.t. our FLU body frame.
+
+            - Z axis is along the **Up** direction.
+
+            | Clockwise rotation about this axis defines a positive **yaw** angle.
+            | Hence, yawing with a positive angle is equivalent to rotated towards the **left** direction wrt our FLU body frame. Or in an anticlockwise fashion in the body XY / FL plane.
+
+        Args:
+            roll_rate (float): Desired roll rate, in radians / second
+            pitch_rate (float): Desired pitch rate, in radians / second
+            yaw_rate (float): Desired yaw rate, in radians / second
+            throttle (float): Desired throttle (between 0.0 to 1.0)
+            duration (float): Desired amount of time (seconds), to send this command for
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+
+        Returns:
+            msgpackrpc.future.Future: future. call .join() to wait for method to finish. Example: client.METHOD().join()
+        """
+        return self.client.call_async('moveByAngleRatesThrottle', roll_rate, -pitch_rate, -yaw_rate, throttle, duration, vehicle_name)
+
+    def setAngleRateControllerGains(self, angle_rate_gains=AngleRateControllerGains(), vehicle_name = ''):
+        """
+        - Modifying these gains will have an affect on *ALL* move*() APIs.
+            This is because any velocity setpoint is converted to an angle level setpoint which is tracked with an angle level controllers.
+            That angle level setpoint is itself tracked with and angle rate controller.
+        - This function should only be called if the default angle rate control PID gains need to be modified.
+
+        Args:
+            angle_rate_gains (AngleRateControllerGains):
+                - Correspond to the roll, pitch, yaw axes, defined in the body frame.
+                - Pass AngleRateControllerGains() to reset gains to default recommended values.
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        """
+        self.client.call('setAngleRateControllerGains', *(angle_rate_gains.to_lists()+(vehicle_name,)))
+
+    def setAngleLevelControllerGains(self, angle_level_gains=AngleLevelControllerGains(), vehicle_name = ''):
+        """
+        - Sets angle level controller gains (used by any API setting angle references - for ex: moveByRollPitchYawZAsync(), moveByRollPitchYawThrottleAsync(), etc)
+        - Modifying these gains will also affect the behaviour of moveByVelocityAsync() API.
+            This is because the AirSim flight controller will track velocity setpoints by converting them to angle set points.
+        - This function should only be called if the default angle level control PID gains need to be modified.
+        - Passing AngleLevelControllerGains() sets gains to default airsim values.
+
+        Args:
+            angle_level_gains (AngleLevelControllerGains):
+                - Correspond to the roll, pitch, yaw axes, defined in the body frame.
+                - Pass AngleLevelControllerGains() to reset gains to default recommended values.
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        """
+        self.client.call('setAngleLevelControllerGains', *(angle_level_gains.to_lists()+(vehicle_name,)))
+
+    def setVelocityControllerGains(self, velocity_gains=VelocityControllerGains(), vehicle_name = ''):
+        """
+        - Sets velocity controller gains for moveByVelocityAsync().
+        - This function should only be called if the default velocity control PID gains need to be modified.
+        - Passing VelocityControllerGains() sets gains to default airsim values.
+
+        Args:
+            velocity_gains (VelocityControllerGains):
+                - Correspond to the world X, Y, Z axes.
+                - Pass VelocityControllerGains() to reset gains to default recommended values.
+                - Modifying velocity controller gains will have an affect on the behaviour of moveOnSplineAsync() and moveOnSplineVelConstraintsAsync(), as they both use velocity control to track the trajectory.
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        """
+        self.client.call('setVelocityControllerGains', *(velocity_gains.to_lists()+(vehicle_name,)))
+
+
+    def setPositionControllerGains(self, position_gains=PositionControllerGains(), vehicle_name = ''):
+        """
+        Sets position controller gains for moveByPositionAsync.
+        This function should only be called if the default position control PID gains need to be modified.
+
+        Args:
+            position_gains (PositionControllerGains):
+                - Correspond to the X, Y, Z axes.
+                - Pass PositionControllerGains() to reset gains to default recommended values.
+            vehicle_name (str, optional): Name of the multirotor to send this command to
+        """
+        self.client.call('setPositionControllerGains', *(position_gains.to_lists()+(vehicle_name,)))
+
+#query vehicle state
+    def getMultirotorState(self, vehicle_name = ''):
+        """
+        The position inside the returned MultirotorState is in the frame of the vehicle's starting point
+
+        Args:
+            vehicle_name (str, optional): Vehicle to get the state of
+
+        Returns:
+            MultirotorState:
+        """
+        return MultirotorState.from_msgpack(self.client.call('getMultirotorState', vehicle_name))
+    getMultirotorState.__annotations__ = {'return': MultirotorState}
+#query rotor states
+    def getRotorStates(self, vehicle_name = ''):
+        """
+        Used to obtain the current state of all a multirotor's rotors. The state includes the speeds,
+        thrusts and torques for all rotors.
+
+        Args:
+            vehicle_name (str, optional): Vehicle to get the rotor state of
+
+        Returns:
+            RotorStates: Containing a timestamp and the speed, thrust and torque of all rotors.
+        """
+        return RotorStates.from_msgpack(self.client.call('getRotorStates', vehicle_name))
+    getRotorStates.__annotations__ = {'return': RotorStates}
+
+#----------------------------------- Car APIs ---------------------------------------------
+class CarClient(VehicleClient, object):
+    def __init__(self, ip = "", port = 41451, timeout_value = 3600):
+        super(CarClient, self).__init__(ip, port, timeout_value)
+
+    def setCarControls(self, controls, vehicle_name = ''):
+        """
+        Control the car using throttle, steering, brake, etc.
+
+        Args:
+            controls (CarControls): Struct containing control values
+            vehicle_name (str, optional): Name of vehicle to be controlled
+        """
+        self.client.call('setCarControls', controls, vehicle_name)
+
+    def getCarState(self, vehicle_name = ''):
+        """
+        The position inside the returned CarState is in the frame of the vehicle's starting point
+
+        Args:
+            vehicle_name (str, optional): Name of vehicle
+
+        Returns:
+            CarState:
+        """
+        state_raw = self.client.call('getCarState', vehicle_name)
+        return CarState.from_msgpack(state_raw)
+
+    def getCarControls(self, vehicle_name=''):
+        """
+        Args:
+            vehicle_name (str, optional): Name of vehicle
+
+        Returns:
+            CarControls:
+        """
+        controls_raw = self.client.call('getCarControls', vehicle_name)
+        return CarControls.from_msgpack(controls_raw)

AirDrone/airsim/pfm.py

@@ -0,0 +1,85 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import re
+import sys
+import pdb
+
+
+def read_pfm(file):
+    """ Read a pfm file """
+    file = open(file, 'rb')
+
+    color = None
+    width = None
+    height = None
+    scale = None
+    endian = None
+
+    header = file.readline().rstrip()
+    header = str(bytes.decode(header, encoding='utf-8'))
+    if header == 'PF':
+        color = True
+    elif header == 'Pf':
+        color = False
+    else:
+        raise Exception('Not a PFM file.')
+
+    pattern = r'^(\d+)\s(\d+)\s$'
+    temp_str = str(bytes.decode(file.readline(), encoding='utf-8'))
+    dim_match = re.match(pattern, temp_str)
+    if dim_match:
+        width, height = map(int, dim_match.groups())
+    else:
+        temp_str += str(bytes.decode(file.readline(), encoding='utf-8'))
+        dim_match = re.match(pattern, temp_str)
+        if dim_match:
+            width, height = map(int, dim_match.groups())
+        else:
+            raise Exception('Malformed PFM header: width, height cannot be found')
+
+    scale = float(file.readline().rstrip())
+    if scale < 0: # little-endian
+        endian = '<'
+        scale = -scale
+    else:
+        endian = '>' # big-endian
+
+    data = np.fromfile(file, endian + 'f')
+    shape = (height, width, 3) if color else (height, width)
+
+    data = np.reshape(data, shape)
+    # DEY: I don't know why this was there.
+    file.close()
+    
+    return data, scale
+
+
+def write_pfm(file, image, scale=1):
+    """ Write a pfm file """
+    file = open(file, 'wb')
+
+    color = None
+
+    if image.dtype.name != 'float32':
+        raise Exception('Image dtype must be float32.')
+
+    if len(image.shape) == 3 and image.shape[2] == 3: # color image
+        color = True
+    elif len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1: # greyscale
+        color = False
+    else:
+        raise Exception('Image must have H x W x 3, H x W x 1 or H x W dimensions.')
+
+    file.write(bytes('PF\n', 'UTF-8') if color else bytes('Pf\n', 'UTF-8'))
+    temp_str = '%d %d\n' % (image.shape[1], image.shape[0])
+    file.write(bytes(temp_str, 'UTF-8'))
+
+    endian = image.dtype.byteorder
+
+    if endian == '<' or endian == '=' and sys.byteorder == 'little':
+        scale = -scale
+
+    temp_str = '%f\n' % scale
+    file.write(bytes(temp_str, 'UTF-8'))
+
+    image.tofile(file)

AirDrone/airsim/types.py

@@ -0,0 +1,580 @@
+from __future__ import print_function
+import msgpackrpc #install as admin: pip install msgpack-rpc-python
+import numpy as np #pip install numpy
+import math
+
+class MsgpackMixin:
+    def __repr__(self):
+        from pprint import pformat
+        return "<" + type(self).__name__ + "> " + pformat(vars(self), indent=4, width=1)
+
+    def to_msgpack(self, *args, **kwargs):
+        return self.__dict__
+
+    @classmethod
+    def from_msgpack(cls, encoded):
+        obj = cls()
+        #obj.__dict__ = {k.decode('utf-8'): (from_msgpack(v.__class__, v) if hasattr(v, "__dict__") else v) for k, v in encoded.items()}
+        obj.__dict__ = { k : (v if not isinstance(v, dict) else getattr(getattr(obj, k).__class__, "from_msgpack")(v)) for k, v in encoded.items()}
+        #return cls(**msgpack.unpack(encoded))
+        return obj
+
+class _ImageType(type):
+    @property
+    def Scene(cls):
+        return 0
+    def DepthPlanar(cls):
+        return 1
+    def DepthPerspective(cls):
+        return 2
+    def DepthVis(cls):
+        return 3
+    def DisparityNormalized(cls):
+        return 4
+    def Segmentation(cls):
+        return 5
+    def SurfaceNormals(cls):
+        return 6
+    def Infrared(cls):
+        return 7
+    def OpticalFlow(cls):
+        return 8
+    def OpticalFlowVis(cls):
+        return 9
+
+    def __getattr__(self, key):
+        if key == 'DepthPlanner':
+            print('\033[31m'+"DepthPlanner has been (correctly) renamed to DepthPlanar. Please use ImageType.DepthPlanar instead."+'\033[0m')
+            raise AttributeError
+
+class ImageType(metaclass=_ImageType):
+    Scene = 0
+    DepthPlanar = 1
+    DepthPerspective = 2
+    DepthVis = 3
+    DisparityNormalized = 4
+    Segmentation = 5
+    SurfaceNormals = 6
+    Infrared = 7
+    OpticalFlow = 8
+    OpticalFlowVis = 9
+
+class DrivetrainType:
+    MaxDegreeOfFreedom = 0
+    ForwardOnly = 1
+
+class LandedState:
+    Landed = 0
+    Flying = 1
+
+class WeatherParameter:
+    Rain = 0
+    Roadwetness = 1
+    Snow = 2
+    RoadSnow = 3
+    MapleLeaf = 4
+    RoadLeaf = 5
+    Dust = 6
+    Fog = 7
+    Enabled = 8
+
+class Vector2r(MsgpackMixin):
+    x_val = 0.0
+    y_val = 0.0
+
+    def __init__(self, x_val = 0.0, y_val = 0.0):
+        self.x_val = x_val
+        self.y_val = y_val
+
+class Vector3r(MsgpackMixin):
+    x_val = 0.0
+    y_val = 0.0
+    z_val = 0.0
+
+    def __init__(self, x_val = 0.0, y_val = 0.0, z_val = 0.0):
+        self.x_val = x_val
+        self.y_val = y_val
+        self.z_val = z_val
+
+    @staticmethod
+    def nanVector3r():
+        return Vector3r(np.nan, np.nan, np.nan)
+
+    def containsNan(self):
+        return (math.isnan(self.x_val) or math.isnan(self.y_val) or math.isnan(self.z_val))
+
+    def __add__(self, other):
+        return Vector3r(self.x_val + other.x_val, self.y_val + other.y_val, self.z_val + other.z_val)
+
+    def __sub__(self, other):
+        return Vector3r(self.x_val - other.x_val, self.y_val - other.y_val, self.z_val - other.z_val)
+
+    def __truediv__(self, other):
+        if type(other) in [int, float] + np.sctypes['int'] + np.sctypes['uint'] + np.sctypes['float']:
+            return Vector3r( self.x_val / other, self.y_val / other, self.z_val / other)
+        else:
+            raise TypeError('unsupported operand type(s) for /: %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def __mul__(self, other):
+        if type(other) in [int, float] + np.sctypes['int'] + np.sctypes['uint'] + np.sctypes['float']:
+            return Vector3r(self.x_val*other, self.y_val*other, self.z_val*other)
+        else:
+            raise TypeError('unsupported operand type(s) for *: %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def dot(self, other):
+        if type(self) == type(other):
+            return self.x_val*other.x_val + self.y_val*other.y_val + self.z_val*other.z_val
+        else:
+            raise TypeError('unsupported operand type(s) for \'dot\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def cross(self, other):
+        if type(self) == type(other):
+            cross_product = np.cross(self.to_numpy_array(), other.to_numpy_array())
+            return Vector3r(cross_product[0], cross_product[1], cross_product[2])
+        else:
+            raise TypeError('unsupported operand type(s) for \'cross\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def get_length(self):
+        return ( self.x_val**2 + self.y_val**2 + self.z_val**2 )**0.5
+
+    def distance_to(self, other):
+        return ( (self.x_val-other.x_val)**2 + (self.y_val-other.y_val)**2 + (self.z_val-other.z_val)**2 )**0.5
+
+    def to_Quaternionr(self):
+        return Quaternionr(self.x_val, self.y_val, self.z_val, 0)
+
+    def to_numpy_array(self):
+        return np.array([self.x_val, self.y_val, self.z_val], dtype=np.float32)
+
+    def __iter__(self):
+        return iter((self.x_val, self.y_val, self.z_val))
+
+class Quaternionr(MsgpackMixin):
+    w_val = 0.0
+    x_val = 0.0
+    y_val = 0.0
+    z_val = 0.0
+
+    def __init__(self, x_val = 0.0, y_val = 0.0, z_val = 0.0, w_val = 1.0):
+        self.x_val = x_val
+        self.y_val = y_val
+        self.z_val = z_val
+        self.w_val = w_val
+
+    @staticmethod
+    def nanQuaternionr():
+        return Quaternionr(np.nan, np.nan, np.nan, np.nan)
+
+    def containsNan(self):
+        return (math.isnan(self.w_val) or math.isnan(self.x_val) or math.isnan(self.y_val) or math.isnan(self.z_val))
+
+    def __add__(self, other):
+        if type(self) == type(other):
+            return Quaternionr( self.x_val+other.x_val, self.y_val+other.y_val, self.z_val+other.z_val, self.w_val+other.w_val )
+        else:
+            raise TypeError('unsupported operand type(s) for +: %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def __mul__(self, other):
+        if type(self) == type(other):
+            t, x, y, z = self.w_val, self.x_val, self.y_val, self.z_val
+            a, b, c, d = other.w_val, other.x_val, other.y_val, other.z_val
+            return Quaternionr( w_val = a*t - b*x - c*y - d*z,
+                                x_val = b*t + a*x + d*y - c*z,
+                                y_val = c*t + a*y + b*z - d*x,
+                                z_val = d*t + z*a + c*x - b*y)
+        else:
+            raise TypeError('unsupported operand type(s) for *: %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def __truediv__(self, other):
+        if type(other) == type(self):
+            return self * other.inverse()
+        elif type(other) in [int, float] + np.sctypes['int'] + np.sctypes['uint'] + np.sctypes['float']:
+            return Quaternionr( self.x_val / other, self.y_val / other, self.z_val / other, self.w_val / other)
+        else:
+            raise TypeError('unsupported operand type(s) for /: %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def dot(self, other):
+        if type(self) == type(other):
+            return self.x_val*other.x_val + self.y_val*other.y_val + self.z_val*other.z_val + self.w_val*other.w_val
+        else:
+            raise TypeError('unsupported operand type(s) for \'dot\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def cross(self, other):
+        if type(self) == type(other):
+            return (self * other - other * self) / 2
+        else:
+            raise TypeError('unsupported operand type(s) for \'cross\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def outer_product(self, other):
+        if type(self) == type(other):
+            return ( self.inverse()*other - other.inverse()*self ) / 2
+        else:
+            raise TypeError('unsupported operand type(s) for \'outer_product\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def rotate(self, other):
+        if type(self) == type(other):
+            if other.get_length() == 1:
+                return other * self * other.inverse()
+            else:
+                raise ValueError('length of the other Quaternionr must be 1')
+        else:
+            raise TypeError('unsupported operand type(s) for \'rotate\': %s and %s' % ( str(type(self)), str(type(other))) )
+
+    def conjugate(self):
+        return Quaternionr(-self.x_val, -self.y_val, -self.z_val, self.w_val)
+
+    def star(self):
+        return self.conjugate()
+
+    def inverse(self):
+        return self.star() / self.dot(self)
+
+    def sgn(self):
+        return self/self.get_length()
+
+    def get_length(self):
+        return ( self.x_val**2 + self.y_val**2 + self.z_val**2 + self.w_val**2 )**0.5
+
+    def to_numpy_array(self):
+        return np.array([self.x_val, self.y_val, self.z_val, self.w_val], dtype=np.float32)
+
+    def __iter__(self):
+        return iter((self.x_val, self.y_val, self.z_val, self.w_val))
+
+class Pose(MsgpackMixin):
+    position = Vector3r()
+    orientation = Quaternionr()
+
+    def __init__(self, position_val = None, orientation_val = None):
+        position_val = position_val if position_val is not None else Vector3r()
+        orientation_val = orientation_val if orientation_val is not None else Quaternionr()
+        self.position = position_val
+        self.orientation = orientation_val
+
+    @staticmethod
+    def nanPose():
+        return Pose(Vector3r.nanVector3r(), Quaternionr.nanQuaternionr())
+
+    def containsNan(self):
+        return (self.position.containsNan() or self.orientation.containsNan())
+
+    def __iter__(self):
+        return iter((self.position, self.orientation))
+
+class CollisionInfo(MsgpackMixin):
+    has_collided = False
+    normal = Vector3r()
+    impact_point = Vector3r()
+    position = Vector3r()
+    penetration_depth = 0.0
+    time_stamp = 0.0
+    object_name = ""
+    object_id = -1
+
+class GeoPoint(MsgpackMixin):
+    latitude = 0.0
+    longitude = 0.0
+    altitude = 0.0
+
+class YawMode(MsgpackMixin):
+    is_rate = True
+    yaw_or_rate = 0.0
+    def __init__(self, is_rate = True, yaw_or_rate = 0.0):
+        self.is_rate = is_rate
+        self.yaw_or_rate = yaw_or_rate
+
+class RCData(MsgpackMixin):
+    timestamp = 0
+    pitch, roll, throttle, yaw = (0.0,)*4 #init 4 variable to 0.0
+    switch1, switch2, switch3, switch4 = (0,)*4
+    switch5, switch6, switch7, switch8 = (0,)*4
+    is_initialized = False
+    is_valid = False
+    def __init__(self, timestamp = 0, pitch = 0.0, roll = 0.0, throttle = 0.0, yaw = 0.0, switch1 = 0,
+                 switch2 = 0, switch3 = 0, switch4 = 0, switch5 = 0, switch6 = 0, switch7 = 0, switch8 = 0, is_initialized = False, is_valid = False):
+        self.timestamp = timestamp
+        self.pitch = pitch
+        self.roll = roll
+        self.throttle = throttle
+        self.yaw = yaw
+        self.switch1 = switch1
+        self.switch2 = switch2
+        self.switch3 = switch3
+        self.switch4 = switch4
+        self.switch5 = switch5
+        self.switch6 = switch6
+        self.switch7 = switch7
+        self.switch8 = switch8
+        self.is_initialized = is_initialized
+        self.is_valid = is_valid
+
+class ImageRequest(MsgpackMixin):
+    camera_name = '0'
+    image_type = ImageType.Scene
+    pixels_as_float = False
+    compress = False
+
+    def __init__(self, camera_name, image_type, pixels_as_float = False, compress = True):
+        # todo: in future remove str(), it's only for compatibility to pre v1.2
+        self.camera_name = str(camera_name)
+        self.image_type = image_type
+        self.pixels_as_float = pixels_as_float
+        self.compress = compress
+
+
+class ImageResponse(MsgpackMixin):
+    image_data_uint8 = np.uint8(0)
+    image_data_float = 0.0
+    camera_position = Vector3r()
+    camera_orientation = Quaternionr()
+    time_stamp = np.uint64(0)
+    message = ''
+    pixels_as_float = 0.0
+    compress = True
+    width = 0
+    height = 0
+    image_type = ImageType.Scene
+
+class CarControls(MsgpackMixin):
+    throttle = 0.0
+    steering = 0.0
+    brake = 0.0
+    handbrake = False
+    is_manual_gear = False
+    manual_gear = 0
+    gear_immediate = True
+
+    def __init__(self, throttle = 0, steering = 0, brake = 0,
+        handbrake = False, is_manual_gear = False, manual_gear = 0, gear_immediate = True):
+        self.throttle = throttle
+        self.steering = steering
+        self.brake = brake
+        self.handbrake = handbrake
+        self.is_manual_gear = is_manual_gear
+        self.manual_gear = manual_gear
+        self.gear_immediate = gear_immediate
+
+
+    def set_throttle(self, throttle_val, forward):
+        if (forward):
+            self.is_manual_gear = False
+            self.manual_gear = 0
+            self.throttle = abs(throttle_val)
+        else:
+            self.is_manual_gear = False
+            self.manual_gear = -1
+            self.throttle = - abs(throttle_val)
+
+class KinematicsState(MsgpackMixin):
+    position = Vector3r()
+    orientation = Quaternionr()
+    linear_velocity = Vector3r()
+    angular_velocity = Vector3r()
+    linear_acceleration = Vector3r()
+    angular_acceleration = Vector3r()
+
+class EnvironmentState(MsgpackMixin):
+    position = Vector3r()
+    geo_point = GeoPoint()
+    gravity = Vector3r()
+    air_pressure = 0.0
+    temperature = 0.0
+    air_density = 0.0
+
+class CarState(MsgpackMixin):
+    speed = 0.0
+    gear = 0
+    rpm = 0.0
+    maxrpm = 0.0
+    handbrake = False
+    collision = CollisionInfo()
+    kinematics_estimated = KinematicsState()
+    timestamp = np.uint64(0)
+
+class MultirotorState(MsgpackMixin):
+    collision = CollisionInfo()
+    kinematics_estimated = KinematicsState()
+    gps_location = GeoPoint()
+    timestamp = np.uint64(0)
+    landed_state = LandedState.Landed
+    rc_data = RCData()
+    ready = False
+    ready_message = ""
+    can_arm = False
+
+class RotorStates(MsgpackMixin):
+    timestamp = np.uint64(0)
+    rotors = []
+
+class ProjectionMatrix(MsgpackMixin):
+    matrix = []
+
+class CameraInfo(MsgpackMixin):
+    pose = Pose()
+    fov = -1
+    proj_mat = ProjectionMatrix()
+
+class LidarData(MsgpackMixin):
+    point_cloud = 0.0
+    time_stamp = np.uint64(0)
+    pose = Pose()
+    segmentation = 0
+
+class ImuData(MsgpackMixin):
+    time_stamp = np.uint64(0)
+    orientation = Quaternionr()
+    angular_velocity = Vector3r()
+    linear_acceleration = Vector3r()
+
+class BarometerData(MsgpackMixin):
+    time_stamp = np.uint64(0)
+    altitude = Quaternionr()
+    pressure = Vector3r()
+    qnh = Vector3r()
+
+class MagnetometerData(MsgpackMixin):
+    time_stamp = np.uint64(0)
+    magnetic_field_body = Vector3r()
+    magnetic_field_covariance = 0.0
+
+class GnssFixType(MsgpackMixin):
+    GNSS_FIX_NO_FIX = 0
+    GNSS_FIX_TIME_ONLY = 1
+    GNSS_FIX_2D_FIX = 2
+    GNSS_FIX_3D_FIX = 3
+
+class GnssReport(MsgpackMixin):
+    geo_point = GeoPoint()
+    eph = 0.0
+    epv = 0.0
+    velocity = Vector3r()
+    fix_type = GnssFixType()
+    time_utc = np.uint64(0)
+
+class GpsData(MsgpackMixin):
+    time_stamp = np.uint64(0)
+    gnss = GnssReport()
+    is_valid = False
+
+class DistanceSensorData(MsgpackMixin):
+    time_stamp = np.uint64(0)
+    distance = 0.0
+    min_distance = 0.0
+    max_distance = 0.0
+    relative_pose = Pose()
+
+class Box2D(MsgpackMixin):
+    min = Vector2r()
+    max = Vector2r()
+
+class Box3D(MsgpackMixin):
+    min = Vector3r()
+    max = Vector3r()
+
+class DetectionInfo(MsgpackMixin):
+    name = ''
+    geo_point = GeoPoint()
+    box2D = Box2D()
+    box3D = Box3D()
+    relative_pose = Pose()
+    
+class PIDGains():
+    """
+    Struct to store values of PID gains. Used to transmit controller gain values while instantiating
+    AngleLevel/AngleRate/Velocity/PositionControllerGains objects.
+
+    Attributes:
+        kP (float): Proportional gain
+        kI (float): Integrator gain
+        kD (float): Derivative gain
+    """
+    def __init__(self, kp, ki, kd):
+        self.kp = kp
+        self.ki = ki
+        self.kd = kd
+
+    def to_list(self):
+        return [self.kp, self.ki, self.kd]
+
+class AngleRateControllerGains():
+    """
+    Struct to contain controller gains used by angle level PID controller
+
+    Attributes:
+        roll_gains (PIDGains): kP, kI, kD for roll axis
+        pitch_gains (PIDGains): kP, kI, kD for pitch axis
+        yaw_gains (PIDGains): kP, kI, kD for yaw axis
+    """
+    def __init__(self, roll_gains = PIDGains(0.25, 0, 0),
+                       pitch_gains = PIDGains(0.25, 0, 0),
+                       yaw_gains = PIDGains(0.25, 0, 0)):
+        self.roll_gains = roll_gains
+        self.pitch_gains = pitch_gains
+        self.yaw_gains = yaw_gains
+
+    def to_lists(self):
+        return [self.roll_gains.kp, self.pitch_gains.kp, self.yaw_gains.kp], [self.roll_gains.ki, self.pitch_gains.ki, self.yaw_gains.ki], [self.roll_gains.kd, self.pitch_gains.kd, self.yaw_gains.kd]
+
+class AngleLevelControllerGains():
+    """
+    Struct to contain controller gains used by angle rate PID controller
+
+    Attributes:
+        roll_gains (PIDGains): kP, kI, kD for roll axis
+        pitch_gains (PIDGains): kP, kI, kD for pitch axis
+        yaw_gains (PIDGains): kP, kI, kD for yaw axis
+    """
+    def __init__(self, roll_gains = PIDGains(2.5, 0, 0),
+                       pitch_gains = PIDGains(2.5, 0, 0),
+                       yaw_gains = PIDGains(2.5, 0, 0)):
+        self.roll_gains = roll_gains
+        self.pitch_gains = pitch_gains
+        self.yaw_gains = yaw_gains
+
+    def to_lists(self):
+        return [self.roll_gains.kp, self.pitch_gains.kp, self.yaw_gains.kp], [self.roll_gains.ki, self.pitch_gains.ki, self.yaw_gains.ki], [self.roll_gains.kd, self.pitch_gains.kd, self.yaw_gains.kd]
+
+class VelocityControllerGains():
+    """
+    Struct to contain controller gains used by velocity PID controller
+
+    Attributes:
+        x_gains (PIDGains): kP, kI, kD for X axis
+        y_gains (PIDGains): kP, kI, kD for Y axis
+        z_gains (PIDGains): kP, kI, kD for Z axis
+    """
+    def __init__(self, x_gains = PIDGains(0.2, 0, 0),
+                       y_gains = PIDGains(0.2, 0, 0),
+                       z_gains = PIDGains(2.0, 2.0, 0)):
+        self.x_gains = x_gains
+        self.y_gains = y_gains
+        self.z_gains = z_gains
+
+    def to_lists(self):
+        return [self.x_gains.kp, self.y_gains.kp, self.z_gains.kp], [self.x_gains.ki, self.y_gains.ki, self.z_gains.ki], [self.x_gains.kd, self.y_gains.kd, self.z_gains.kd]
+
+class PositionControllerGains():
+    """
+    Struct to contain controller gains used by position PID controller
+
+    Attributes:
+        x_gains (PIDGains): kP, kI, kD for X axis
+        y_gains (PIDGains): kP, kI, kD for Y axis
+        z_gains (PIDGains): kP, kI, kD for Z axis
+    """
+    def __init__(self, x_gains = PIDGains(0.25, 0, 0),
+                       y_gains = PIDGains(0.25, 0, 0),
+                       z_gains = PIDGains(0.25, 0, 0)):
+        self.x_gains = x_gains
+        self.y_gains = y_gains
+        self.z_gains = z_gains
+
+    def to_lists(self):
+        return [self.x_gains.kp, self.y_gains.kp, self.z_gains.kp], [self.x_gains.ki, self.y_gains.ki, self.z_gains.ki], [self.x_gains.kd, self.y_gains.kd, self.z_gains.kd]
+
+class MeshPositionVertexBuffersResponse(MsgpackMixin):
+    position = Vector3r()
+    orientation = Quaternionr()
+    vertices = 0.0
+    indices = 0.0
+    name = ''

AirDrone/airsim/utils.py

@@ -0,0 +1,208 @@
+import numpy as np #pip install numpy
+import math
+import time
+import sys
+import os
+import inspect
+import types
+import re
+import logging
+
+from .types import *
+
+
+def string_to_uint8_array(bstr):
+    return np.fromstring(bstr, np.uint8)
+    
+def string_to_float_array(bstr):
+    return np.fromstring(bstr, np.float32)
+    
+def list_to_2d_float_array(flst, width, height):
+    return np.reshape(np.asarray(flst, np.float32), (height, width))
+    
+def get_pfm_array(response):
+    return list_to_2d_float_array(response.image_data_float, response.width, response.height)
+
+    
+def get_public_fields(obj):
+    return [attr for attr in dir(obj)
+                            if not (attr.startswith("_") 
+                            or inspect.isbuiltin(attr)
+                            or inspect.isfunction(attr)
+                            or inspect.ismethod(attr))]
+
+
+    
+def to_dict(obj):
+    return dict([attr, getattr(obj, attr)] for attr in get_public_fields(obj))
+
+    
+def to_str(obj):
+    return str(to_dict(obj))
+
+    
+def write_file(filename, bstr):
+    """
+    Write binary data to file.
+    Used for writing compressed PNG images
+    """
+    with open(filename, 'wb') as afile:
+        afile.write(bstr)
+
+# helper method for converting getOrientation to roll/pitch/yaw
+# https:#en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
+    
+def to_eularian_angles(q):
+    z = q.z_val
+    y = q.y_val
+    x = q.x_val
+    w = q.w_val
+    ysqr = y * y
+
+    # roll (x-axis rotation)
+    t0 = +2.0 * (w*x + y*z)
+    t1 = +1.0 - 2.0*(x*x + ysqr)
+    roll = math.atan2(t0, t1)
+
+    # pitch (y-axis rotation)
+    t2 = +2.0 * (w*y - z*x)
+    if (t2 > 1.0):
+        t2 = 1
+    if (t2 < -1.0):
+        t2 = -1.0
+    pitch = math.asin(t2)
+
+    # yaw (z-axis rotation)
+    t3 = +2.0 * (w*z + x*y)
+    t4 = +1.0 - 2.0 * (ysqr + z*z)
+    yaw = math.atan2(t3, t4)
+
+    return (pitch, roll, yaw)
+
+    
+def to_quaternion(pitch, roll, yaw):
+    t0 = math.cos(yaw * 0.5)
+    t1 = math.sin(yaw * 0.5)
+    t2 = math.cos(roll * 0.5)
+    t3 = math.sin(roll * 0.5)
+    t4 = math.cos(pitch * 0.5)
+    t5 = math.sin(pitch * 0.5)
+
+    q = Quaternionr()
+    q.w_val = t0 * t2 * t4 + t1 * t3 * t5 #w
+    q.x_val = t0 * t3 * t4 - t1 * t2 * t5 #x
+    q.y_val = t0 * t2 * t5 + t1 * t3 * t4 #y
+    q.z_val = t1 * t2 * t4 - t0 * t3 * t5 #z
+    return q
+
+    
+def wait_key(message = ''):
+    ''' Wait for a key press on the console and return it. '''
+    if message != '':
+        print (message)
+
+    result = None
+    if os.name == 'nt':
+        import msvcrt
+        result = msvcrt.getch()
+    else:
+        import termios
+        fd = sys.stdin.fileno()
+
+        oldterm = termios.tcgetattr(fd)
+        newattr = termios.tcgetattr(fd)
+        newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
+        termios.tcsetattr(fd, termios.TCSANOW, newattr)
+
+        try:
+            result = sys.stdin.read(1)
+        except IOError:
+            pass
+        finally:
+            termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
+
+    return result
+
+    
+def read_pfm(file):
+    """ Read a pfm file """
+    file = open(file, 'rb')
+
+    color = None
+    width = None
+    height = None
+    scale = None
+    endian = None
+
+    header = file.readline().rstrip()
+    header = str(bytes.decode(header, encoding='utf-8'))
+    if header == 'PF':
+        color = True
+    elif header == 'Pf':
+        color = False
+    else:
+        raise Exception('Not a PFM file.')
+
+    temp_str = str(bytes.decode(file.readline(), encoding='utf-8'))
+    dim_match = re.match(r'^(\d+)\s(\d+)\s$', temp_str)
+    if dim_match:
+        width, height = map(int, dim_match.groups())
+    else:
+        raise Exception('Malformed PFM header.')
+
+    scale = float(file.readline().rstrip())
+    if scale < 0: # little-endian
+        endian = '<'
+        scale = -scale
+    else:
+        endian = '>' # big-endian
+
+    data = np.fromfile(file, endian + 'f')
+    shape = (height, width, 3) if color else (height, width)
+
+    data = np.reshape(data, shape)
+    # DEY: I don't know why this was there.
+    file.close()
+    
+    return data, scale
+
+    
+def write_pfm(file, image, scale=1):
+    """ Write a pfm file """
+    file = open(file, 'wb')
+
+    color = None
+
+    if image.dtype.name != 'float32':
+        raise Exception('Image dtype must be float32.')
+
+    if len(image.shape) == 3 and image.shape[2] == 3: # color image
+        color = True
+    elif len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1: # grayscale
+        color = False
+    else:
+        raise Exception('Image must have H x W x 3, H x W x 1 or H x W dimensions.')
+
+    file.write('PF\n'.encode('utf-8')  if color else 'Pf\n'.encode('utf-8'))
+    temp_str = '%d %d\n' % (image.shape[1], image.shape[0])
+    file.write(temp_str.encode('utf-8'))
+
+    endian = image.dtype.byteorder
+
+    if endian == '<' or endian == '=' and sys.byteorder == 'little':
+        scale = -scale
+
+    temp_str = '%f\n' % scale
+    file.write(temp_str.encode('utf-8'))
+
+    image.tofile(file)
+
+    
+def write_png(filename, image):
+    """ image must be numpy array H X W X channels
+    """
+    import cv2      # pip install opencv-python
+
+    ret = cv2.imwrite(filename, image)
+    if not ret:
+        logging.error(f"Writing PNG file {filename} failed")

AirDrone/create_ir_segmentation_map.py

@@ -0,0 +1,213 @@
+import numpy
+import cv2
+import time
+import sys
+import os
+import random
+from airsim import *
+
+def radiance(absoluteTemperature, emissivity, dx=0.01, response=None):
+    """
+    title::
+        radiance
+
+    description::
+        Calculates radiance and integrated radiance over a bandpass of 8 to 14
+        microns, given temperature and emissivity, using Planck's Law.
+
+    inputs::
+        absoluteTemperature
+            temperture of object in [K]
+
+            either a single temperature or a numpy
+            array of temperatures, of shape (temperatures.shape[0], 1)
+        emissivity
+            average emissivity (number between 0 and 1 representing the
+            efficiency with which it emits radiation; if 1, it is an ideal 
+            blackbody) of object over the bandpass
+
+            either a single emissivity or a numpy array of emissivities, of 
+            shape (emissivities.shape[0], 1)
+        dx
+            discrete spacing between the wavelengths for evaluation of
+            radiance and integration [default is 0.1]
+        response
+            optional response of the camera over the bandpass of 8 to 14 
+            microns [default is None, for no response provided]
+    
+    returns::
+        radiance
+            discrete spectrum of radiance over bandpass
+        integratedRadiance
+            integration of radiance spectrum over bandpass (to simulate
+            the readout from a sensor)
+
+    author::
+        Elizabeth Bondi
+    """
+    wavelength = numpy.arange(8,14,dx)
+    c1 = 1.19104e8 # (2 * 6.62607*10^-34 [Js] * 
+                   # (2.99792458 * 10^14 [micron/s])^2 * 10^12 to convert 
+                   # denominator from microns^3 to microns * m^2)
+    c2 = 1.43879e4 # (hc/k) [micron * K]
+    if response is not None:
+        radiance = response * emissivity * (c1 / ((wavelength**5) * \
+                   (numpy.exp(c2 / (wavelength * absoluteTemperature )) - 1)))
+    else:
+        radiance = emissivity * (c1 / ((wavelength**5) * (numpy.exp(c2 / \
+                   (wavelength * absoluteTemperature )) - 1)))
+    if absoluteTemperature.ndim > 1:
+        return radiance, numpy.trapz(radiance, dx=dx, axis=1)
+    else:
+        return radiance, numpy.trapz(radiance, dx=dx)
+
+
+def get_new_temp_emiss_from_radiance(tempEmissivity, response):
+    """
+    title::
+        get_new_temp_emiss_from_radiance
+
+    description::
+        Transform tempEmissivity from [objectName, temperature, emissivity]
+        to [objectName, "radiance"] using radiance calculation above.
+
+    input::
+        tempEmissivity
+            numpy array containing the temperature and emissivity of each
+            object (e.g., each row has: [objectName, temperature, emissivity])
+        response
+            camera response (same input as radiance, set to None if lacking
+            this information)
+
+    returns::
+        tempEmissivityNew
+            tempEmissivity, now with [objectName, "radiance"]; note that 
+            integrated radiance (L) is divided by the maximum and multiplied 
+            by 255 in order to simulate an 8 bit digital count observed by the 
+            thermal sensor, since radiance and digital count are linearly 
+            related, so it's [objectName, simulated thermal digital count]
+
+    author::
+        Elizabeth Bondi
+    """
+    numObjects = tempEmissivity.shape[0]
+
+    L = radiance(tempEmissivity[:,1].reshape((-1,1)).astype(numpy.float64), 
+                 tempEmissivity[:,2].reshape((-1,1)).astype(numpy.float64), 
+                 response=response)[1].flatten() 
+    L = ((L / L.max()) * 255).astype(numpy.uint8)
+
+    tempEmissivityNew = numpy.hstack((
+        tempEmissivity[:,0].reshape((numObjects,1)), 
+        L.reshape((numObjects,1))))
+
+    return tempEmissivityNew
+
+def set_segmentation_ids(segIdDict, tempEmissivityNew, client):
+    """
+    title::
+        set_segmentation_ids
+
+    description::
+        Set stencil IDs in environment so that stencil IDs correspond to
+        simulated thermal digital counts (e.g., if elephant has a simulated
+        digital count of 219, set stencil ID to 219).
+
+    input::
+        segIdDict
+            dictionary mapping environment object names to the object names in
+            the first column of tempEmissivityNew 
+        tempEmissivityNew
+            numpy array containing object names and corresponding simulated
+            thermal digital count
+        client
+            connection to AirSim (e.g., client = MultirotorClient() for UAV)
+
+    author::
+        Elizabeth Bondi
+    """
+
+    #First set everything to 0.
+    success = client.simSetSegmentationObjectID("[\w]*", 0, True);
+    if not success:
+        print('There was a problem setting all segmentation object IDs to 0. ')
+        sys.exit(1)
+
+    #Next set all objects of interest provided to corresponding object IDs
+    #segIdDict values MUST match tempEmissivityNew labels.
+    for key in segIdDict:
+        objectID = int(tempEmissivityNew[numpy.where(tempEmissivityNew == \
+                                                     segIdDict[key])[0],1][0])
+
+        success = client.simSetSegmentationObjectID("[\w]*"+key+"[\w]*", 
+                                                    objectID, True);
+        if not success:
+            print('There was a problem setting {0} segmentation object ID to {1!s}, or no {0} was found.'.format(key, objectID))
+            
+    time.sleep(0.1)
+
+
+if __name__ == '__main__':
+
+    #Connect to AirSim, UAV mode.
+    client = MultirotorClient()
+    client.confirmConnection()
+    
+    #Multiple same object settings
+    cubeList = client.simListSceneObjects('.*?Cube.*?')
+    cubeDict = {}
+    for x in cubeList:
+        cubeDict[x] = 'tree'
+ 
+
+    segIdDict = {
+        'Floor':'soil',
+                 }
+    
+    segIdDict.update(cubeDict)
+    #Choose temperature values for winter or summer.
+    #"""
+    #winter
+    tempEmissivity = numpy.array([['elephant',290,0.96], 
+                                  ['zebra',298,0.98],
+                                  ['rhinoceros',291,0.96],
+                                  ['hippopotamus',290,0.96],
+                                  ['crocodile',295,0.96],
+                                  ['human',292,0.985], 
+                                  ['tree',273,0.952], 
+                                  ['grass',273,0.958], 
+                                  ['soil',278,0.914], 
+                                  ['shrub',300,0.3],
+                                  ['truck',273,0.8],
+                                  ['water',273,0.96]])
+    #"""
+    """
+    #summer
+    tempEmissivity = numpy.array([['elephant',298,0.96], 
+                                  ['zebra',307,0.98],
+                                  ['rhinoceros',299,0.96],
+                                  ['hippopotamus',298,0.96],
+                                  ['crocodile',303,0.96],
+                                  ['human',301,0.985], 
+                                  ['tree',293,0.952], 
+                                  ['grass',293,0.958], 
+                                  ['soil',288,0.914], 
+                                  ['shrub',293,0.986],
+                                  ['truck',293,0.8],
+                                  ['water',293,0.96]])
+    """
+
+    #Read camera response.
+    response = None
+    camResponseFile = 'camera_response.npy'
+    try:
+      numpy.load(camResponseFile)
+    except:
+      print("{} not found. Using default response.".format(camResponseFile))
+
+    #Calculate radiance.
+    tempEmissivityNew = get_new_temp_emiss_from_radiance(tempEmissivity, 
+                                                         response)
+
+    #Set IDs in AirSim environment.
+    set_segmentation_ids(segIdDict, tempEmissivityNew, client)

README.md

@@ -0,0 +1,96 @@
+---
+license: apache-2.0
+tags:
+- Swarm
+- UAVS
+- Autonoumous
+- Flying
+- Simulator
+pretty_name: U2USim-2
+size_categories:
+- 10K<n<100K
+---
+
+## Abstract
+Swarm UAV autonomous flight for Long-Horizon (LH) tasks is crucial for advancing the low-altitude economy. 
+However, existing methods focus only on specific basic tasks due to dataset limitations, failing in real-world deployment for LH tasks. 
+LH tasks are not mere concatenations of basic tasks, requiring handling long-term dependencies, maintaining persistent states, and adapting to dynamic goal shifts. 
+This paper presents U2UData-2, the first large-scale swarm UAV autonomous flight dataset for LH tasks and the first scalable swarm UAV data online collection and algorithm closed-loop verification platform. 
+The dataset is captured by 15 UAVs in autonomous collaborative flights for LH tasks, comprising 12 scenes, 720 traces, 120 hours, 600 seconds per trajectory, 4.32M LiDAR frames, and 12.96M RGB frames. 
+This dataset also includes brightness, temperature, humidity, smoke, and airflow values covering all flight routes. 
+The platform supports the customization of simulators, UAVs, sensors, flight algorithms, formation modes, and LH tasks. 
+Through a visual control window, this platform allows users to collect customized datasets through one-click deployment online and to verify algorithms by closed-loop simulation. 
+U2UData-2 also introduces an LH task for **wildlife conservation** and provides comprehensive benchmarks with 9 SOTA models. 
+U2UData-2 can be found at https://fengtt42.github.io/U2UData-2/.
+
+## Helper
+If you need the full dataset, you can send an email to obtain the Baidu Cloud link for downloading.
+PPM is a binary image format. If you need PNG format, we provide conversion code, which you can download and convert by yourself.
+I have full parameter information for each trajectory. If you need other parameter information, such as IMU, detailed drone parameters, etc., you can contact me by email at any time.
+
+## Cite
+@inproceedings{feng2025u2udata2scalableswarmuavs,
+
+    title={U2UData-2: A Scalable Swarm UAVs Autonomous Flight Dataset for Long-horizon Tasks}, 
+
+    author={Tongtong Feng and Xin Wang and Feilin Han and Leping Zhang and Wenwu Zhu},
+
+    year={2025},
+
+    url={https://arxiv.org/abs/2509.00055}
+
+}
+
+U2UData-2: https://huggingface.co/papers/2509.00055
+
+## Web Link
+https://fengtt42.github.io/U2UData-2/
+
+
+
+## 1. 文件分类
+- U2USim_2_Windows_version 仿真环境的windows打包版本
+- U2USim_2_Linux_version 仿真环境的Linux20.04打包版本
+- Settings.json 配置文件　放在\home\用户名\Documents\AirSim或者C:\Users\用户名\Documents\AirSim下 是对插件的一些预定义设置
+- AirDrone 基于API的算法控制、键盘控制、可视化交互控制器
+
+## 2. 系统需求
+### 2.1 PC需求
+- 内存至少32G以上
+- 显卡 RTX 4080，7900 XTX
+- CPU 主流CPU应该都行
+### 2.2 手柄 (经过测试的)
+- Xbox One， Xbox series X/S 的手柄都行，但是Xbox精英2代手柄不行
+- PS5 DuelSense controller 
+
+## 3. 运行环境需求和控制方式
+### 3.1 U2USim_2_Windows_version
+- 不需要安装额外的运行库
+- 手柄控制 左手摇杆左右控制转向，上下飞机高度，右手控制飞机倾斜（移动），但是会让飞机下降
+- 仿真环境的键盘控制（在使用了EnableKeyboardControl之后无效）
+    - Backspace 飞机位置重置
+    - 键盘1234 打开图像可视化窗口
+    - F Fpv（第一人称）模式
+    - / 飞机固定在视角中下部
+    - End 重置整个仿真环境（重新打开关卡）
+    - R 录制传感器数据，鼠标点右下角红色按钮是同样的功能
+
+### 3.2 U2USim_2_Linux_version
+- 控制方式和Windows相同
+- ROS信息获取参考 https://zhuanlan.zhihu.com/p/678127741
+- Airsim ROS package 仓库 https://github.com/seventyzlp/Codename-Aleph
+
+### 3.3 AirDrone
+- 安装python运行库
+    - PyQt5
+    - keyboard
+    - numpy
+    - msgpack-rpc-python
+- 需要运行的主文件是AirDroneClient.py
+- 需要先打开仿真环境后，再启动这个控制器，不然会黑屏
+- 在点击EnableKeyboardControl按钮后，会强制接管所有键盘输入事件，关闭需要结束程序
+    - 键盘控制K是起飞，WASD 前后左右移动，上下 飞机高度升高降低， 左右控制飞机转向
+- 点击按键控制飞机不受影响
+- 在使用API控制飞机后，手柄的控制会被自动禁用，按下ExitApiControl按钮后可以重新使用手柄
+
+

U2USim_2_Linux_version/Landscape3.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+UE_TRUE_SCRIPT_NAME=$(echo \"$0\" | xargs readlink -f)
+UE_PROJECT_ROOT=$(dirname "$UE_TRUE_SCRIPT_NAME")
+chmod +x "$UE_PROJECT_ROOT/Landscape3/Binaries/Linux/Landscape3-Linux-Shipping"
+"$UE_PROJECT_ROOT/Landscape3/Binaries/Linux/Landscape3-Linux-Shipping" Landscape3 "$@" 

U2USim_2_Linux_version/Landscape3/Binaries/Linux/Landscape3-Linux-Shipping

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0afecd849886fd767b556f7f0a1b8c3211e7419e20522e1b197ff21de990150
+size 164025472

U2USim_2_Linux_version/Landscape3/Content/Paks/Landscape3-Linux.pak

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20eb1e3887b8588ad491dd90c517178adfea74e86ea117d02ba31f6d4d6604c3
+size 1566276852

U2USim_2_Linux_version/Manifest_NonUFSFiles_Linux.txt

@@ -0,0 +1,2 @@
+Landscape3/Binaries/Linux/Landscape3-Linux-Shipping	2025-06-04T11:55:07.248Z
+Landscape3.sh	2025-06-04T11:55:28.951Z

U2USim_2_Windows_version/Engine/Binaries/ThirdParty/DbgHelp/dbghelp.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e728908137ccf8326a1e955656fc8b5b2ee57d130aa7d9fb47d9fea77366ffb4
+size 1885072

U2USim_2_Windows_version/Engine/Binaries/ThirdParty/NVIDIA/NVaftermath/Win64/GFSDK_Aftermath_Lib.x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c0918fb5d68831c33136805a772e6250c1111a9769240994ce991ed38808870
+size 1881544

U2USim_2_Windows_version/Engine/Binaries/ThirdParty/Vorbis/Win64/VS2015/libvorbis_64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd31d4dd32474d5d0ef7d571d70a7907f5a477b2c8dbfbbfc371c5481dfa5419
+size 1730504

U2USim_2_Windows_version/Engine/Binaries/ThirdParty/Windows/XAudio2_9/x64/xaudio2_9redist.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e34d1250d42d5c8eb368c78d5b179db86a91eaee4443b17c265f53c619aed465
+size 863776

U2USim_2_Windows_version/Engine/Extras/Redist/en-us/UEPrereqSetup_x64.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef1ac9b2347702667e6a2a280bf2bcd55462882444a7c6981be74ac34df971f0
+size 50596640

U2USim_2_Windows_version/Landscape3.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b75b1f266b9ede2414af4eccf9d67586681e1362263a6ddebd51e77749c1e2b
+size 145920

U2USim_2_Windows_version/Landscape3/Binaries/Win64/D3D12/D3D12Core.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6b78379aa99185b0e48e65fd63ed2ec25b5a227f1a74afba4b5d93ae76a4475
+size 5508496

U2USim_2_Windows_version/Landscape3/Binaries/Win64/Landscape3-Win64-Shipping.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:185b14b41e63ce70920b85a7ecfc109d746207ce737b7c1f4fa8edb2f65e1626
+size 123694592

U2USim_2_Windows_version/Landscape3/Binaries/Win64/OpenImageDenoise.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb216867cd83c061ae446694d540ec0f27ecb35223c9acd0bb4de93d172f69f7
+size 49787744

U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_filesystem-mt-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec5b976cafea739a8a0c747ccf33225def32e83255b41adeb4d14b8e5e718c0f
+size 157128

U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_program_options-mt-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61d48946d97285436840a3ceaac1949e15306b14bfc9d04e15434de23554284d
+size 356808

U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_python39-mt-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5daf42ec764d2b9a624a466b0ecdbdff98306558319b992a308d2b26684ac708
+size 208328

U2USim_2_Windows_version/Landscape3/Binaries/Win64/boost_regex-mt-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bfa1f6e8ba039b129ba920553700684bc97fe16f87906bb3a5d50785fdb5299
+size 244168