fixes

AirLib/include/vehicles/computervision/api/ComputerVisionApi.hpp

@@ -15,7 +15,7 @@ namespace airlib
     {
     public:
         ComputerVisionApi(const AirSimSettings::VehicleSetting* vehicle_setting, std::shared_ptr<SensorFactory> sensor_factory,
-                    const Kinematics::State& state, const Environment& environment)
+            const Kinematics::State& state, const Environment& environment)
             : ComputerVisionApiBase(vehicle_setting, sensor_factory, state, environment), home_geopoint_(environment.getHomeGeoPoint())
         {
         }
@@ -44,10 +44,7 @@ namespace airlib
         // VehicleApiBase Implementation
         virtual void enableApiControl(bool is_enabled) override
         {
-            if (api_control_enabled_ != is_enabled) {
-                last_controls_ = CarControls();
-                api_control_enabled_ = is_enabled;
-            }
+            unused(is_enabled);
         }
 
         virtual bool isApiControlEnabled() const override
@@ -74,15 +71,15 @@ namespace airlib
             last_car_state_ = car_state;
         }
 
-        virtual const ComputerVisionState& getCarState() const override
+        virtual const ComputerVisionState& getComputerVisionState() const override
         {
             return last_car_state_;
         }
 
     private:
         bool api_control_enabled_ = false;
         GeoPoint home_geopoint_;
-        CarState last_car_state_;
+        ComputerVisionState last_car_state_;
     };
 }
 }

AirLib/include/vehicles/computervision/api/ComputerVisionApiBase.hpp

@@ -21,6 +21,10 @@ class ComputerVisionApiBase : public VehicleApiBase
         Kinematics::State kinematics_estimated;
         uint64_t timestamp;
 
+        ComputerVisionState()
+        {
+        }
+
         ComputerVisionState(const Kinematics::State& kinematics_estimated_val, uint64_t timestamp_val)
             : kinematics_estimated(kinematics_estimated_val), timestamp(timestamp_val)
         {
@@ -93,7 +97,7 @@ class ComputerVisionApiBase : public VehicleApiBase
         sensor_factory_->createSensorsFromSettings(sensor_settings, sensors_, sensor_storage_);
     }
 
-    virtual ComputerVisionState getComputerVisionState() const = 0;
+    virtual const ComputerVisionState& getComputerVisionState() const = 0;
     virtual void updateComputerVisionState(const ComputerVisionState& state) = 0;
 
     virtual ~ComputerVisionApiBase() = default;

AirLib/src/vehicles/computervision/api/ComputerVisionRpcLibServer.cpp

@@ -9,7 +9,6 @@
 
 #include "vehicles/computervision/api/ComputerVisionRpcLibServer.hpp"
 
-
 #include "common/Common.hpp"
 STRICT_MODE_OFF
 
@@ -31,31 +30,29 @@ STRICT_MODE_OFF
 
 #include "vehicles/computervision/api/ComputerVisionRpcLibAdapators.hpp"
 
-
 STRICT_MODE_ON
 
-
-namespace msr { namespace airlib {
-
-typedef msr::airlib_rpclib::ComputerVisionRpcLibAdapators ComputerVisionRpcLibAdapators;
-
-ComputerVisionRpcLibServer::ComputerVisionRpcLibServer(ApiProvider* api_provider, string server_address, uint16_t port)
-    : RpcLibServerBase(api_provider, server_address, port)
+namespace msr
 {
-    (static_cast<rpc::server*>(getServer()))->
-        bind("getComputerVisionState", [&](const std::string& vehicle_name) -> ComputerVisionRpcLibAdapators::ComputerVisionState {
-        return ComputerVisionRpcLibAdapators::ComputerVisionState(getVehicleApi(vehicle_name)->getComputerVisionState());
-    });
-
-}
-
-//required for pimpl
-ComputerVisionRpcLibServer::~ComputerVisionRpcLibServer()
-{
-}
-
-}} //namespace
-
+    namespace airlib
+    {
+
+        typedef msr::airlib_rpclib::ComputerVisionRpcLibAdaptors ComputerVisionRpcLibAdaptors;
+
+        ComputerVisionRpcLibServer::ComputerVisionRpcLibServer(ApiProvider* api_provider, string server_address, uint16_t port)
+            : RpcLibServerBase(api_provider, server_address, port)
+        {
+            (static_cast<rpc::server*>(getServer()))->bind("getComputerVisionState", [&](const std::string& vehicle_name) -> ComputerVisionRpcLibAdaptors::ComputerVisionState {
+                return ComputerVisionRpcLibAdaptors::ComputerVisionState(getVehicleApi(vehicle_name)->getComputerVisionState());
+                });
+        }
+
+        //required for pimpl
+        ComputerVisionRpcLibServer::~ComputerVisionRpcLibServer()
+        {
+        }
+    }
+} //namespace
 
 #endif
 #endif

Unreal/Plugins/AirSim/Source/AirSim.Build.cs

@@ -156,4 +156,4 @@ private bool AddLibDependency(string LibName, string LibPath, string LibFileName
 
         return isLibrarySupported;
     }
-}
+}

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/ComputerVisionPawnApi.cpp

@@ -10,7 +10,7 @@ ComputerVisionPawnApi::ComputerVisionPawnApi(AComputerVisionPawn* pawn, const ms
 
 msr::airlib::ComputerVisionApiBase::ComputerVisionState ComputerVisionPawnApi::getComputerVisionState() const
 {
-    ComputerVisionApiBase::ComputerVisionState state(
+    msr::airlib::ComputerVisionApiBase::ComputerVisionState state(
         *pawn_kinematics_,
         msr::airlib::ClockFactory::get()->nowNanos()
     );

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/ComputerVisionPawnApi.h

@@ -1,17 +1,18 @@
 #pragma once
 
 #include "vehicles/computervision/api/ComputerVisionApiBase.hpp"
+#include "vehicles/computervision/api/ComputerVisionApi.hpp"
 #include "physics/Kinematics.hpp"
 #include "ComputerVisionPawn.h"
 
 
-class ComputerVisionPawnApi : public msr::airlib::ComputerVisionApiBase {
+class ComputerVisionPawnApi{
 public:
     typedef msr::airlib::ImageCaptureBase ImageCaptureBase;
 
     ComputerVisionPawnApi(AComputerVisionPawn* pawn, const msr::airlib::Kinematics::State* pawn_kinematics, msr::airlib::ComputerVisionApiBase* vehicle_api);
 
-    ComputerVisionApiBase::ComputerVisionState getComputerVisionState() const;
+    msr::airlib::ComputerVisionApiBase::ComputerVisionState getComputerVisionState() const;
 
     void reset();
     void update(float delta = 0);

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/ComputerVisionPawnSimApi.cpp

@@ -17,20 +17,32 @@ void ComputerVisionPawnSimApi::initialize()
 
     //create vehicle params
     std::shared_ptr<UnrealSensorFactory> sensor_factory = std::make_shared<UnrealSensorFactory>(getPawn(), &getNedTransform());
-    vehicle_api_ = std::unique_ptr<ComputerVisionApiBase>(new ComputerVisionPawnApi(getVehicleSetting(),sensor_factory, getGroundTruthKinematics(), home_geopoint,
-        getVehicleSetting(), sensor_factory,
-        (*getGroundTruthKinematics()), (*getGroundTruthEnvironment())));
+    vehicle_api_ = std::unique_ptr<ComputerVisionApiBase>(new ComputerVisionApi(getVehicleSetting(), sensor_factory, (*getGroundTruthKinematics()), (*getGroundTruthEnvironment())));
     pawn_api_ = std::unique_ptr<ComputerVisionPawnApi>(new ComputerVisionPawnApi(static_cast<AComputerVisionPawn*>(getPawn()), getGroundTruthKinematics(), vehicle_api_.get()));
 
     //TODO: should do reset() here?
 }
 
+std::string ComputerVisionPawnSimApi::getRecordFileLine(bool is_header_line) const
+{
+    std::string common_line = PawnSimApi::getRecordFileLine(is_header_line);
+    if (is_header_line) {
+        return common_line +
+            "Throttle\tSteering\tBrake\tGear\tHandbrake\tRPM\tSpeed\t";
+    }
+
+    const auto& state = pawn_api_->getComputerVisionState();
+
+    std::ostringstream ss;
+    ss << common_line;
+    return ss.str();
+}
 
 //these are called on render ticks
 void ComputerVisionPawnSimApi::updateRenderedState(float dt)
 {
     PawnSimApi::updateRenderedState(dt);
-    
+
     vehicle_api_->getStatusMessages(vehicle_api_messages_);
 
 }
@@ -45,7 +57,7 @@ void ComputerVisionPawnSimApi::updateRendering(float dt)
     try {
         vehicle_api_->sendTelemetry(dt);
     }
-    catch (std::exception &e) {
+    catch (std::exception& e) {
         UAirBlueprintLib::LogMessage(FString(e.what()), TEXT(""), LogDebugLevel::Failure, 30);
     }
 }
@@ -66,5 +78,12 @@ void ComputerVisionPawnSimApi::update(float delta)
     PawnSimApi::update(delta);
 }
 
+void ComputerVisionPawnSimApi::reportState(StateReporter& reporter)
+{
+    PawnSimApi::reportState(reporter);
+
+    vehicle_api_->reportState(reporter);
+}
+
 //*** End: UpdatableState implementation ***//
 

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/ComputerVisionPawnSimApi.h

@@ -7,6 +7,7 @@
 #include "PawnEvents.h"
 #include "PawnSimApi.h"
 #include "vehicles/computervision/api/ComputerVisionApiBase.hpp"
+#include "vehicles/computervision/api/ComputerVisionApi.hpp"
 #include "physics//Kinematics.hpp"
 #include "common/Common.hpp"
 #include "common/CommonStructs.hpp"

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/SimModeComputerVision.cpp

@@ -51,12 +51,21 @@ void ASimModeComputerVision::pause(bool is_paused)
 void ASimModeComputerVision::continueForTime(double seconds)
 {
 	pause_period_start_ = ClockFactory::get()->nowNanos();
-	pause_period_ = seconds;
+	pause_period_ = seconds * current_clockspeed_;
+	pause(false);
+}
+
+void ASimModeComputerVision::continueForFrames(uint32_t frames)
+{
+	targetFrameNumber_ = GFrameNumber + frames;
+	frame_countdown_enabled_ = true;
 	pause(false);
 }
 
 void ASimModeComputerVision::setupClockSpeed()
 {
+	Super::setupClockSpeed();
+
 	current_clockspeed_ = getSettings().clock_speed;
 
 	//setup clock in PhysX
@@ -66,20 +75,33 @@ void ASimModeComputerVision::setupClockSpeed()
 
 void ASimModeComputerVision::Tick(float DeltaSeconds)
 {
-	Super::Tick(DeltaSeconds);
+    Super::Tick(DeltaSeconds);
 
-	if (pause_period_start_ > 0) {
-		if (ClockFactory::get()->elapsedSince(pause_period_start_) >= pause_period_) {
-			if (!isPaused())
-				pause(true);
+    if (!isPaused())
+        ClockFactory::get()->stepBy(DeltaSeconds);
 
-			pause_period_start_ = 0;
-		}
-	}
+    if (pause_period_start_ > 0) {
+        if (ClockFactory::get()->elapsedSince(pause_period_start_) >= pause_period_) {
+            if (!isPaused())
+                pause(true);
+
+            pause_period_start_ = 0;
+        }
+    }
+
+    if (frame_countdown_enabled_) {
+        if (targetFrameNumber_ <= GFrameNumber) {
+            if (!isPaused())
+                pause(true);
+
+            frame_countdown_enabled_ = false;
+}
+    }
 }
 
 std::unique_ptr<msr::airlib::ApiServerBase> ASimModeComputerVision::createApiServer() const
 {
+
 #ifdef AIRLIB_NO_RPC
     return ASimModeBase::createApiServer();
 #else
@@ -125,10 +147,11 @@ void ASimModeComputerVision::initializeVehiclePawn(APawn* pawn)
 std::unique_ptr<PawnSimApi> ASimModeComputerVision::createVehicleSimApi(
     const PawnSimApi::Params& pawn_sim_api_params) const
 {
-	auto vehicle_sim_api = std::unique_ptr<PawnSimApi>(new ComputerVisionPawnSimApi(pawn_sim_api_params));
-	vehicle_sim_api->initialize();
-	vehicle_sim_api->reset();
-	return vehicle_sim_api;
+    auto vehicle_pawn = static_cast<TVehiclePawn*>(pawn_sim_api_params.pawn);
+    auto vehicle_sim_api = std::unique_ptr<PawnSimApi>(new ComputerVisionPawnSimApi(pawn_sim_api_params));
+    vehicle_sim_api->initialize();
+    vehicle_sim_api->reset();
+    return vehicle_sim_api;
 }
 
 msr::airlib::VehicleApiBase* ASimModeComputerVision::getVehicleApi(const PawnSimApi::Params& pawn_sim_api_params,

Unreal/Plugins/AirSim/Source/Vehicles/ComputerVision/SimModeComputerVision.h

@@ -22,6 +22,7 @@ class AIRSIM_API ASimModeComputerVision : public ASimModeBase
 	virtual bool isPaused() const override;
 	virtual void pause(bool is_paused) override;
 	virtual void continueForTime(double seconds) override;
+	virtual void continueForFrames(uint32_t frames) override;
 
 private:
 	typedef msr::airlib::ClockFactory ClockFactory;
@@ -53,4 +54,6 @@ class AIRSIM_API ASimModeComputerVision : public ASimModeBase
 	std::atomic<float> current_clockspeed_;
 	std::atomic<TTimeDelta> pause_period_;
 	std::atomic<TTimePoint> pause_period_start_;
+	uint32_t targetFrameNumber_;
+	std::atomic_bool frame_countdown_enabled_;
 };