Upload 23 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+pic/image[[:space:]]1.png filter=lfs diff=lfs merge=lfs -text

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())

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>

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>

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

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()

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()
+

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)

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.

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()

airsim/__init__.py

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

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)

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)

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 = ''

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")

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)