Make operator runnable

AirSim/PythonClient/airsim/client.py

@@ -1,7 +1,7 @@
 from __future__ import print_function
 
-from .utils import *
-from .types import *
+from fsds.utils import *
+from fsds.types import *
 
 import msgpackrpc #install as admin: pip install msgpack-rpc-python
 import numpy as np #pip install numpy
@@ -673,57 +673,6 @@ def moveByAngleZAsync(self, pitch, roll, z, yaw, duration, vehicle_name = ''):
     def moveByAngleThrottleAsync(self, pitch, roll, throttle, yaw_rate, duration, vehicle_name = ''):
         return self.client.call_async('moveByAngleThrottle', pitch, roll, throttle, yaw_rate, 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 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)
 
@@ -733,9 +682,6 @@ def rotateByYawRateAsync(self, 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 = ''):
         """
@@ -963,78 +909,6 @@ def moveByAngleRatesThrottleAsync(self, roll_rate, pitch_rate, yaw_rate, throttl
         """
         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 = ''):
-        """
-        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}
-
 
 # -----------------------------------  Car APIs ---------------------------------------------
 class CarClient(VehicleClient, object):

operator/operator.py

@@ -58,7 +58,7 @@ def index(self):
 
     def launch_simulator(self):
         self.check_accesstoken()
-
+        
         # Abort if simulator is already running
         if self.simulation_process is not None:
             abort(400, description='Simulation already running.')

operator/requirements.txt

@@ -1 +1,4 @@
 flask
+msgpack-rpc-python
+numpy
+opencv-contrib-python