diff --git a/AirLib/include/api/RpcLibClientBase.hpp b/AirLib/include/api/RpcLibClientBase.hpp index c0fffa55c7..cc3914b6a1 100644 --- a/AirLib/include/api/RpcLibClientBase.hpp +++ b/AirLib/include/api/RpcLibClientBase.hpp @@ -114,6 +114,24 @@ namespace airlib vector simGetImages(vector request, const std::string& vehicle_name = "", bool external = false); vector simGetImage(const std::string& camera_name, ImageCaptureBase::ImageType type, const std::string& vehicle_name = "", bool external = false); + //CinemAirSim + std::vector simGetPresetLensSettings(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + std::string simGetLensSettings(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simSetPresetLensSettings(const std::string& preset_lens_settings, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + std::vector simGetPresetFilmbackSettings(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simSetPresetFilmbackSettings(const std::string& preset_filmback_settings, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + std::string simGetFilmbackSettings(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + float simSetFilmbackSettings(const float sensor_width, const float sensor_heigth, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + float simGetFocalLength(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simSetFocalLength(float focal_length, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simEnableManualFocus(const bool enable, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + float simGetFocusDistance(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simSetFocusDistance(float focus_distance, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + float simGetFocusAperture(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simSetFocusAperture(const float focus_aperture, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + void simEnableFocusPlane(const bool enable, const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + std::string simGetCurrentFieldOfView(const std::string& camera_name, const std::string& vehicle_name = "", bool external = false); + //end CinemAirSim bool simTestLineOfSightToPoint(const msr::airlib::GeoPoint& point, const std::string& vehicle_name = ""); bool simTestLineOfSightBetweenPoints(const msr::airlib::GeoPoint& point1, const msr::airlib::GeoPoint& point2); vector simGetWorldExtents(); diff --git a/AirLib/include/api/WorldSimApiBase.hpp b/AirLib/include/api/WorldSimApiBase.hpp index 52e002e0be..e7fc7c3754 100644 --- a/AirLib/include/api/WorldSimApiBase.hpp +++ b/AirLib/include/api/WorldSimApiBase.hpp @@ -104,6 +104,25 @@ namespace airlib const std::string& vehicle_name, bool external) const = 0; virtual std::vector getImage(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) const = 0; + //CinemAirSim + virtual std::vector getPresetLensSettings(const CameraDetails& camera_details) = 0; + virtual std::string getLensSettings(const CameraDetails& camera_details) = 0; + virtual void setPresetLensSettings(std::string, const CameraDetails& camera_details) = 0; + virtual std::vector getPresetFilmbackSettings(const CameraDetails& camera_details) = 0; + virtual void setPresetFilmbackSettings(std::string, const CameraDetails& camera_details) = 0; + virtual std::string getFilmbackSettings(const CameraDetails& camera_details) = 0; + virtual float setFilmbackSettings(float width, float height, const CameraDetails& camera_details) = 0; + virtual float getFocalLength(const CameraDetails& camera_details) = 0; + virtual void setFocalLength(float focal_length, const CameraDetails& camera_details) = 0; + virtual void enableManualFocus(bool enable, const CameraDetails& camera_details) = 0; + virtual float getFocusDistance(const CameraDetails& camera_details) = 0; + virtual void setFocusDistance(float focus_distance, const CameraDetails& camera_details) = 0; + virtual float getFocusAperture(const CameraDetails& camera_details) = 0; + virtual void setFocusAperture(float focus_aperture, const CameraDetails& camera_details) = 0; + virtual void enableFocusPlane(bool enable, const CameraDetails& camera_details) = 0; + virtual std::string getCurrentFieldOfView(const CameraDetails& camera_details) = 0; + //end CinemAirSim + virtual void addDetectionFilterMeshName(ImageCaptureBase::ImageType image_type, const std::string& mesh_name, const CameraDetails& camera_details) = 0; virtual void setDetectionFilterRadius(ImageCaptureBase::ImageType image_type, float radius_cm, const CameraDetails& camera_details) = 0; virtual void clearDetectionMeshNames(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) = 0; diff --git a/AirLib/src/api/RpcLibClientBase.cpp b/AirLib/src/api/RpcLibClientBase.cpp index df9039e5ce..f9ea4b59ec 100644 --- a/AirLib/src/api/RpcLibClientBase.cpp +++ b/AirLib/src/api/RpcLibClientBase.cpp @@ -269,13 +269,90 @@ __pragma(warning(disable : 4239)) vector RpcLibClientBase::simGetImage(const std::string& camera_name, ImageCaptureBase::ImageType type, const std::string& vehicle_name, bool external) { vector result = pimpl_->client.call("simGetImage", camera_name, type, vehicle_name, external).as>(); - if (result.size() == 1) { - // rpclib has a bug with serializing empty vectors, so we return a 1 byte vector instead. - result.clear(); - } return result; } + //CinemAirSim + std::vector RpcLibClientBase::simGetPresetLensSettings(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetPresetLensSettings", camera_name, vehicle_name, external).as>(); + } + + std::string RpcLibClientBase::simGetLensSettings(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetLensSettings", camera_name, vehicle_name, external).as(); + } + + void RpcLibClientBase::simSetPresetLensSettings(const std::string& preset_lens_settings, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simSetPresetLensSettings", preset_lens_settings, camera_name, vehicle_name, external); + } + + std::vector RpcLibClientBase::simGetPresetFilmbackSettings(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetPresetFilmbackSettings", camera_name, vehicle_name, external).as>(); + } + + void RpcLibClientBase::simSetPresetFilmbackSettings(const std::string& preset_filmback_settings, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simSetPresetFilmbackSettings", preset_filmback_settings, camera_name, vehicle_name, external); + } + + std::string RpcLibClientBase::simGetFilmbackSettings(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetFilmbackSettings", camera_name, vehicle_name, external).as(); + } + + float RpcLibClientBase::simSetFilmbackSettings(const float sensor_width, const float sensor_height, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simSetFilmbackSettings", sensor_width, sensor_height, camera_name, vehicle_name, external).as(); + } + + float RpcLibClientBase::simGetFocalLength(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetFocalLength", camera_name, vehicle_name, external).as(); + } + + void RpcLibClientBase::simSetFocalLength(const float focal_length, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simSetFocalLength", focal_length, camera_name, vehicle_name, external); + } + + void RpcLibClientBase::simEnableManualFocus(const bool enable, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simEnableManualFocus", enable, camera_name, vehicle_name, external); + } + + float RpcLibClientBase::simGetFocusDistance(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetFocusDistance", camera_name, vehicle_name, external).as(); + } + void RpcLibClientBase::simSetFocusDistance(const float focus_distance, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simSetFocusDistance", focus_distance, camera_name, vehicle_name, external); + } + + float RpcLibClientBase::simGetFocusAperture(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetFocusAperture", camera_name, vehicle_name, external).as(); + } + + void RpcLibClientBase::simSetFocusAperture(const float focus_aperture, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simSetFocusAperture", focus_aperture, camera_name, vehicle_name, external); + } + + void RpcLibClientBase::simEnableFocusPlane(const bool enable, const std::string& camera_name, const std::string& vehicle_name, bool external) + { + pimpl_->client.call("simEnableFocusPlane", enable, camera_name, vehicle_name, external); + } + + std::string RpcLibClientBase::simGetCurrentFieldOfView(const std::string& camera_name, const std::string& vehicle_name, bool external) + { + return pimpl_->client.call("simGetCurrentFieldOfView", camera_name, vehicle_name, external).as(); + } + //End CinemAirSim + // Minor TODO: consider msgpack magic for GeoPoint, so we can have one arg instead of three bool RpcLibClientBase::simTestLineOfSightToPoint(const msr::airlib::GeoPoint& point, const std::string& vehicle_name) { diff --git a/AirLib/src/api/RpcLibServerBase.cpp b/AirLib/src/api/RpcLibServerBase.cpp index f8a4aa3a24..8ee4ae6841 100644 --- a/AirLib/src/api/RpcLibServerBase.cpp +++ b/AirLib/src/api/RpcLibServerBase.cpp @@ -153,6 +153,73 @@ namespace airlib return getWorldSimApi()->getImage(type, CameraDetails(camera_name, vehicle_name, external)); }); + //CinemAirSim + pimpl_->server.bind("simGetPresetLensSettings", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> vector { + return getWorldSimApi()->getPresetLensSettings(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetLensSettings", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> string { + return getWorldSimApi()->getLensSettings(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetPresetLensSettings", [&](const std::string preset_lens_settings, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->setPresetLensSettings(preset_lens_settings, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetPresetFilmbackSettings", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> vector { + return getWorldSimApi()->getPresetFilmbackSettings(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetPresetFilmbackSettings", [&](const std::string preset_filmback_settings, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->setPresetFilmbackSettings(preset_filmback_settings, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetFilmbackSettings", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> string { + return getWorldSimApi()->getFilmbackSettings(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetFilmbackSettings", [&](const float width, const float heigth, const std::string& camera_name, const std::string& vehicle_name, bool external) -> float { + return getWorldSimApi()->setFilmbackSettings(width, heigth, CameraDetails(camera_name, vehicle_name, external)); + ; + }); + + pimpl_->server.bind("simGetFocalLength", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> float { + return getWorldSimApi()->getFocalLength(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetFocalLength", [&](const float focal_lenght, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->setFocalLength(focal_lenght, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simEnableManualFocus", [&](const bool enable, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->enableManualFocus(enable, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetFocusDistance", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> float { + return getWorldSimApi()->getFocusDistance(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetFocusDistance", [&](const float focus_distance, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->setFocusDistance(focus_distance, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetFocusAperture", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> float { + return getWorldSimApi()->getFocusAperture(CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simSetFocusAperture", [&](const float focus_aperture, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->setFocusAperture(focus_aperture, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simEnableFocusPlane", [&](const bool enable, const std::string& camera_name, const std::string& vehicle_name, bool external) -> void { + getWorldSimApi()->enableFocusPlane(enable, CameraDetails(camera_name, vehicle_name, external)); + }); + + pimpl_->server.bind("simGetCurrentFieldOfView", [&](const std::string& camera_name, const std::string& vehicle_name, bool external) -> string { + return getWorldSimApi()->getCurrentFieldOfView(CameraDetails(camera_name, vehicle_name, external)); + }); + //end CinemAirSim + pimpl_->server.bind("simTestLineOfSightToPoint", [&](const RpcLibAdaptorsBase::GeoPoint& point, const std::string& vehicle_name) -> bool { return getVehicleSimApi(vehicle_name)->testLineOfSightToPoint(point.to()); }); diff --git a/PythonClient/airsim/client.py b/PythonClient/airsim/client.py index f179be3d22..d20f5498ef 100644 --- a/PythonClient/airsim/client.py +++ b/PythonClient/airsim/client.py @@ -16,7 +16,7 @@ def __init__(self, ip = "", port = 41451, timeout_value = 3600): 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 --------------------------------------------- +#----------------------------------- Common vehicle APIs --------------------------------------------- def reset(self): """ Reset the vehicle to its original starting state @@ -46,7 +46,7 @@ def getMinRequiredServerVersion(self): def getMinRequiredClientVersion(self): return self.client.call('getMinRequiredClientVersion') - # basic flight control +#basic flight control def enableApiControl(self, is_enabled, vehicle_name = ''): """ Enables or disables API control for vehicle corresponding to vehicle_name @@ -218,6 +218,7 @@ def simSetObjectMaterialFromTexture(self, object_name, texture_path): # 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 @@ -237,7 +238,7 @@ def simSetTimeOfDay(self, is_enabled, start_datetime = "", is_start_datetime_dst """ self.client.call('simSetTimeOfDay', is_enabled, start_datetime, is_start_datetime_dst, celestial_clock_speed, update_interval_secs, move_sun) - # weather +#weather def simEnableWeather(self, enable): """ Enable Weather effects. Needs to be called before using `simSetWeatherParameter` API @@ -257,9 +258,9 @@ def simSetWeatherParameter(self, param, val): """ self.client.call('simSetWeatherParameter', param, val) - # camera control - # simGetImage returns compressed png in array of bytes - # image_type uses one of the ImageType members +#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 @@ -277,18 +278,18 @@ def simGetImage(self, camera_name, image_type, vehicle_name = '', external = Fal Returns: Binary string literal of compressed png image """ - # todo: in future remove below, it's only for compatibility to pre v1.2 +#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, msgpack decides to encode it as a string unfortunately. +#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 +#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 @@ -306,6 +307,70 @@ def simGetImages(self, requests, vehicle_name = '', external = False): 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 @@ -356,7 +421,7 @@ def simRunConsoleCommand(self, command): """ return self.client.call('simRunConsoleCommand', command) - # gets the static meshes in the unreal scene +#gets the static meshes in the unreal scene def simGetMeshPositionVertexBuffers(self): """ Returns the static meshes that make up the scene @@ -648,7 +713,7 @@ def simGetCameraInfo(self, camera_name, vehicle_name = '', external=False): Returns: CameraInfo: """ - # TODO: below str() conversion is only needed for legacy reason and should be removed in future +#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): @@ -704,7 +769,7 @@ def simSetCameraPose(self, camera_name, pose, vehicle_name = '', external = Fals 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 +#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): @@ -717,7 +782,7 @@ def simSetCameraFov(self, camera_name, fov_degrees, vehicle_name = '', external 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 +#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 = ''): @@ -761,7 +826,8 @@ def simGetGroundTruthEnvironment(self, vehicle_name = ''): return EnvironmentState.from_msgpack(env_state) simGetGroundTruthEnvironment.__annotations__ = {'return': EnvironmentState} - # sensor APIs + +#sensor APIs def getImuData(self, imu_name = '', vehicle_name = ''): """ Args: @@ -843,7 +909,7 @@ def simGetLidarSegmentation(self, lidar_name = '', vehicle_name = ''): logging.warning("simGetLidarSegmentation API is deprecated, use getLidarData() API instead") return self.getLidarData(lidar_name, vehicle_name).segmentation - # Plotting APIs +#Plotting APIs def simFlushPersistentMarkers(self): """ Clear any persistent markers - those plotted with setting `is_persistent=True` in the APIs below @@ -955,7 +1021,7 @@ def cancelLastTask(self, vehicle_name = ''): """ self.client.call('cancelLastTask', vehicle_name) - # Recording APIs +#Recording APIs def startRecording(self): """ Start Recording @@ -1003,7 +1069,7 @@ def simCreateVoxelGrid(self, position, x, y, z, res, of): """ return self.client.call('simCreateVoxelGrid', position, x, y, z, res, of) - # Add new vehicle via RPC +#Add new vehicle via RPC def simAddVehicle(self, vehicle_name, vehicle_type, pose, pawn_path = ""): """ Create vehicle at runtime @@ -1037,7 +1103,7 @@ def getSettingsString(self): """ return self.client.call('getSettingsString') -# ----------------------------------- Multirotor APIs --------------------------------------------- +#----------------------------------- Multirotor APIs --------------------------------------------- class MultirotorClient(VehicleClient, object): def __init__(self, ip = "", port = 41451, timeout_value = 3600): super(MultirotorClient, self).__init__(ip, port, timeout_value) @@ -1081,7 +1147,7 @@ def goHomeAsync(self, timeout_sec = 3e+38, vehicle_name = ''): """ return self.client.call_async('goHome', timeout_sec, vehicle_name) - # APIs for control +#APIs for control def moveByVelocityBodyFrameAsync(self, vx, vy, vz, duration, drivetrain = DrivetrainType.MaxDegreeOfFreedom, yaw_mode = YawMode(), vehicle_name = ''): """ Args: @@ -1188,7 +1254,7 @@ def hoverAsync(self, vehicle_name = ''): def moveByRC(self, rcdata = RCData(), vehicle_name = ''): return self.client.call('moveByRC', rcdata, vehicle_name) - # low-level control API +#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 @@ -1475,7 +1541,7 @@ def setPositionControllerGains(self, position_gains=PositionControllerGains(), v """ self.client.call('setPositionControllerGains', *(position_gains.to_lists()+(vehicle_name,))) - # query vehicle state +#query vehicle state def getMultirotorState(self, vehicle_name = ''): """ Args: @@ -1486,7 +1552,7 @@ def getMultirotorState(self, vehicle_name = ''): """ return MultirotorState.from_msgpack(self.client.call('getMultirotorState', vehicle_name)) getMultirotorState.__annotations__ = {'return': MultirotorState} - # query rotor states +#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, @@ -1501,7 +1567,7 @@ def getRotorStates(self, vehicle_name = ''): return RotorStates.from_msgpack(self.client.call('getRotorStates', vehicle_name)) getRotorStates.__annotations__ = {'return': RotorStates} -# ----------------------------------- Car APIs --------------------------------------------- +#----------------------------------- Car APIs --------------------------------------------- class CarClient(VehicleClient, object): def __init__(self, ip = "", port = 41451, timeout_value = 3600): super(CarClient, self).__init__(ip, port, timeout_value) diff --git a/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.cpp b/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.cpp index 3fc62a70d9..6bdbe80c5a 100644 --- a/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.cpp +++ b/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.cpp @@ -353,6 +353,138 @@ std::vector WorldSimApi::getImage(ImageCaptureBase::ImageType image_typ return std::vector(); } +//CinemAirSim +std::vector WorldSimApi::getPresetLensSettings(const CameraDetails& camera_details) +{ + std::vector result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getPresetLensSettings is not supported on unity") + .c_str()); + return result; +} + +std::string WorldSimApi::getLensSettings(const CameraDetails& camera_details) +{ + std::string result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getLensSettings is not supported on unity") + .c_str()); + return result; +} + +void WorldSimApi::setPresetLensSettings(std::string preset, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "setPresetLensSettings is not supported on unity") + .c_str()); +} + +std::vector WorldSimApi::getPresetFilmbackSettings(const CameraDetails& camera_details) +{ + std::vector result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getPresetFilmbackSettings is not supported on unity") + .c_str()); + return result; +} + +void WorldSimApi::setPresetFilmbackSettings(std::string preset, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "setPresetFilmbackSettings is not supported on unity") + .c_str()); +} + +std::string WorldSimApi::getFilmbackSettings(const CameraDetails& camera_details) +{ + std::string result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getFilmbackSettings is not supported on unity") + .c_str()); + return result; +} + +float WorldSimApi::setFilmbackSettings(float width, float height, const CameraDetails& camera_details) +{ + float result; + throw std::invalid_argument(common_utils::Utils::stringf( + "setFilmbackSettings is not supported on unity") + .c_str()); + return result; +} + +float WorldSimApi::getFocalLength(const CameraDetails& camera_details) +{ + float result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getFocalLength is not supported on unity") + .c_str()); + return result; +} + +void WorldSimApi::setFocalLength(float focal_length, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "setFocalLength is not supported on unity") + .c_str()); +} + +void WorldSimApi::enableManualFocus(bool enable, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "enableManualFocus is not supported on unity") + .c_str()); +} + +float WorldSimApi::getFocusDistance(const CameraDetails& camera_details) +{ + float result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getFocusDistance is not supported on unity") + .c_str()); + return result; +} + +void WorldSimApi::setFocusDistance(float focus_distance, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "setFocusDistance is not supported on unity") + .c_str()); +} + +float WorldSimApi::getFocusAperture(const CameraDetails& camera_details) +{ + float result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getFocusAperture is not supported on unity") + .c_str()); + return result; +} + +void WorldSimApi::setFocusAperture(float focus_aperture, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "setFocusAperture is not supported on unity") + .c_str()); +} + +void WorldSimApi::enableFocusPlane(bool enable, const CameraDetails& camera_details) +{ + throw std::invalid_argument(common_utils::Utils::stringf( + "enableFocusPlane is not supported on unity") + .c_str()); +} + +std::string WorldSimApi::getCurrentFieldOfView(const CameraDetails& camera_details) +{ + std::string result; + throw std::invalid_argument(common_utils::Utils::stringf( + "getCurrentFieldOfView is not supported on unity") + .c_str()); + return result; +} +//End CinemAirSim + void WorldSimApi::addDetectionFilterMeshName(ImageCaptureBase::ImageType image_type, const std::string& mesh_name, const CameraDetails& camera_details) { unused(camera_details); diff --git a/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.h b/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.h index c88ea68e65..def2b04ed8 100644 --- a/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.h +++ b/Unity/AirLibWrapper/AirsimWrapper/Source/WorldSimApi.h @@ -89,6 +89,25 @@ class WorldSimApi : public msr::airlib::WorldSimApiBase const std::string& vehicle_name, bool external) const override; virtual std::vector getImage(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) const override; + //CinemAirSim + virtual std::vector getPresetLensSettings(const CameraDetails& camera_details) override; + virtual std::string getLensSettings(const CameraDetails& camera_details) override; + virtual void setPresetLensSettings(std::string preset, const CameraDetails& camera_details) override; + virtual std::vector getPresetFilmbackSettings(const CameraDetails& camera_details) override; + virtual void setPresetFilmbackSettings(std::string preset, const CameraDetails& camera_details) override; + virtual std::string getFilmbackSettings(const CameraDetails& camera_details) override; + virtual float setFilmbackSettings(float width, float height, const CameraDetails& camera_details) override; + virtual float getFocalLength(const CameraDetails& camera_details) override; + virtual void setFocalLength(float focal_length, const CameraDetails& camera_details) override; + virtual void enableManualFocus(bool enable, const CameraDetails& camera_details) override; + virtual float getFocusDistance(const CameraDetails& camera_details) override; + virtual void setFocusDistance(float focus_distance, const CameraDetails& camera_details) override; + virtual float getFocusAperture(const CameraDetails& camera_details) override; + virtual void setFocusAperture(float focus_aperture, const CameraDetails& camera_details) override; + virtual void enableFocusPlane(bool enable, const CameraDetails& camera_details) override; + virtual std::string getCurrentFieldOfView(const CameraDetails& camera_details) override; + //end CinemAirSim + virtual void addDetectionFilterMeshName(ImageCaptureBase::ImageType image_type, const std::string& mesh_name, const CameraDetails& camera_details) override; virtual void setDetectionFilterRadius(ImageCaptureBase::ImageType image_type, float radius_cm, const CameraDetails& camera_details) override; virtual void clearDetectionMeshNames(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) override; diff --git a/Unreal/Plugins/AirSim/Source/AirSim.Build.cs b/Unreal/Plugins/AirSim/Source/AirSim.Build.cs index 986dc14a50..17024a35b6 100644 --- a/Unreal/Plugins/AirSim/Source/AirSim.Build.cs +++ b/Unreal/Plugins/AirSim/Source/AirSim.Build.cs @@ -78,7 +78,7 @@ public AirSim(ReadOnlyTargetRules Target) : base(Target) bEnableExceptions = true; - PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "ImageWrapper", "RenderCore", "RHI", "AssetRegistry", "PhysicsCore", "PhysXVehicles", "PhysXVehicleLib", "PhysX", "APEX", "Landscape" }); + PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "ImageWrapper", "RenderCore", "RHI", "AssetRegistry", "PhysicsCore", "PhysXVehicles", "PhysXVehicleLib", "PhysX", "APEX", "Landscape", "CinematicCamera" }); PrivateDependencyModuleNames.AddRange(new string[] { "UMG", "Slate", "SlateCore" }); //suppress VC++ proprietary warnings diff --git a/Unreal/Plugins/AirSim/Source/PIPCamera.cpp b/Unreal/Plugins/AirSim/Source/PIPCamera.cpp index 20c06893b1..f56c769c32 100644 --- a/Unreal/Plugins/AirSim/Source/PIPCamera.cpp +++ b/Unreal/Plugins/AirSim/Source/PIPCamera.cpp @@ -10,7 +10,10 @@ #include #include "AirBlueprintLib.h" -APIPCamera::APIPCamera() +//CinemAirSim +APIPCamera::APIPCamera(const FObjectInitializer& ObjectInitializer) + : Super(ObjectInitializer + .SetDefaultSubobjectClass(TEXT("CameraComponent"))) { static ConstructorHelpers::FObjectFinder mat_finder(TEXT("Material'/AirSim/HUDAssets/CameraSensorNoise.CameraSensorNoise'")); if (mat_finder.Succeeded()) { @@ -51,7 +54,8 @@ void APIPCamera::PostInitializeComponents() { Super::PostInitializeComponents(); - camera_ = UAirBlueprintLib::GetActorComponent(this, TEXT("CameraComponent")); + //CinemAirSim + camera_ = UAirBlueprintLib::GetActorComponent(this, TEXT("CameraComponent")); captures_.Init(nullptr, imageTypeCount()); render_targets_.Init(nullptr, imageTypeCount()); detections_.Init(nullptr, imageTypeCount()); @@ -85,6 +89,8 @@ void APIPCamera::PostInitializeComponents() detections_[i]->Deactivate(); } } + //set initial focal length + camera_->CurrentFocalLength = 11.9; } void APIPCamera::BeginPlay() @@ -393,11 +399,13 @@ void APIPCamera::setupCameraFromSettings(const APIPCamera::CameraSetting& camera } setDistortionMaterial(image_type, captures_[image_type], captures_[image_type]->PostProcessSettings); setNoiseMaterial(image_type, captures_[image_type], captures_[image_type]->PostProcessSettings, noise_setting); + copyCameraSettingsToSceneCapture(camera_, captures_[image_type]); //CinemAirSim } else { //camera component updateCameraSetting(camera_, capture_setting, ned_transform); setDistortionMaterial(image_type, camera_, camera_->PostProcessSettings); setNoiseMaterial(image_type, camera_, camera_->PostProcessSettings, noise_setting); + copyCameraSettingsToAllSceneCapture(camera_); //CinemAirSim } } } @@ -426,7 +434,8 @@ void APIPCamera::updateCaptureComponentSetting(USceneCaptureComponent2D* capture updateCameraPostProcessingSetting(capture->PostProcessSettings, setting); } -void APIPCamera::updateCameraSetting(UCameraComponent* camera, const CaptureSetting& setting, const NedTransform& ned_transform) +//CinemAirSim +void APIPCamera::updateCameraSetting(UCineCameraComponent* camera, const CaptureSetting& setting, const NedTransform& ned_transform) { //if (!std::isnan(setting.target_gamma)) // camera-> = setting.target_gamma; @@ -605,3 +614,179 @@ void APIPCamera::onViewModeChanged(bool nodisplay) } } } + +//CinemAirSim methods +std::vector APIPCamera::getPresetLensSettings() const +{ + std::vector vector; + const TArray lens_presets = camera_->GetLensPresets(); + for (const FNamedLensPreset preset : lens_presets) { + std::ostringstream current_lens_string; + std::string name = (TCHAR_TO_UTF8(*preset.Name)); + + current_lens_string << "Name: " << name << ";\n\t MinFocalLength: " << preset.LensSettings.MinFocalLength << "; \t MaxFocalLength: " << preset.LensSettings.MaxFocalLength; + current_lens_string << "\n\t Min FStop: " << preset.LensSettings.MinFStop << "; \t Max Fstop: " << preset.LensSettings.MaxFStop; + vector.push_back(current_lens_string.str()); + } + return vector; +} + +std::string APIPCamera::getLensSettings() const +{ + const FCameraLensSettings current_lens_params = camera_->LensSettings; + + std::ostringstream current_lens_string; + + const FString lens_preset_name = camera_->GetLensPresetName(); + std::string name = (TCHAR_TO_UTF8(*lens_preset_name)); + + current_lens_string << "Name: " << name; + current_lens_string << ";\n\t MinFocalLength: " << current_lens_params.MinFocalLength; + current_lens_string << "; \t MaxFocalLength: " << current_lens_params.MaxFocalLength; + current_lens_string << "\n\t Min FStop: " << current_lens_params.MinFStop; + current_lens_string << "; \t Max Fstop: " << current_lens_params.MaxFStop; + current_lens_string << "\n\t Diaphragm Blade Count: " << current_lens_params.DiaphragmBladeCount; + current_lens_string << "\n\t Minimum focus distance: " << current_lens_params.MinimumFocusDistance; + + return current_lens_string.str(); +} + +void APIPCamera::setPresetLensSettings(std::string preset_string) +{ + const FString preset(preset_string.c_str()); + camera_->SetLensPresetByName(preset); + copyCameraSettingsToAllSceneCapture(camera_); +} + +std::vector APIPCamera::getPresetFilmbackSettings() const +{ + std::vector vector_all_presets; + TArray lens_presets = camera_->GetFilmbackPresets(); + for (const FNamedFilmbackPreset preset : lens_presets) { + std::ostringstream preset_string; + std::string name = (TCHAR_TO_UTF8(*preset.Name)); + + preset_string << "Name: " << name << ";\n\t Sensor Width: " << preset.FilmbackSettings.SensorWidth << "; \t Sensor Height: " << preset.FilmbackSettings.SensorHeight; + preset_string << "\n\t Sensor Aspect Ratio: " << preset.FilmbackSettings.SensorAspectRatio; + vector_all_presets.push_back(preset_string.str()); + } + return vector_all_presets; +} + +void APIPCamera::setPresetFilmbackSettings(std::string preset_string) +{ + const FString preset(preset_string.c_str()); + camera_->SetFilmbackPresetByName(preset); + copyCameraSettingsToAllSceneCapture(camera_); +} + +std::string APIPCamera::getFilmbackSettings() const +{ + FCameraFilmbackSettings current_filmback_settings = camera_->Filmback; + + const FString filmback_present_name = camera_->GetFilmbackPresetName(); + std::ostringstream current_filmback_string; + std::string name = (TCHAR_TO_UTF8(*filmback_present_name)); + + current_filmback_string << "Name: " << name << ";\n\t Sensor Width: " << current_filmback_settings.SensorWidth << "; \t Sensor Height: " << current_filmback_settings.SensorHeight; + current_filmback_string << "\n\t Sensor Aspect Ratio: " << current_filmback_settings.SensorAspectRatio; + return current_filmback_string.str(); +} + +float APIPCamera::setFilmbackSettings(float sensor_width, float sensor_height) +{ + camera_->Filmback.SensorWidth = sensor_width; + camera_->Filmback.SensorHeight = sensor_height; + + copyCameraSettingsToAllSceneCapture(camera_); + + return camera_->Filmback.SensorAspectRatio; +} + +float APIPCamera::getFocalLength() const +{ + return camera_->CurrentFocalLength; +} + +void APIPCamera::setFocalLength(float focal_length) +{ + camera_->CurrentFocalLength = focal_length; + copyCameraSettingsToAllSceneCapture(camera_); +} + +void APIPCamera::enableManualFocus(bool enable) +{ + if (enable) { + camera_->FocusSettings.FocusMethod = ECameraFocusMethod::Manual; + } + else { + camera_->FocusSettings.FocusMethod = ECameraFocusMethod::Disable; + } + copyCameraSettingsToAllSceneCapture(camera_); +} + +float APIPCamera::getFocusDistance() const +{ + return camera_->FocusSettings.ManualFocusDistance; +} + +void APIPCamera::setFocusDistance(float focus_distance) +{ + camera_->FocusSettings.ManualFocusDistance = focus_distance; + copyCameraSettingsToAllSceneCapture(camera_); +} + +float APIPCamera::getFocusAperture() const +{ + return camera_->CurrentAperture; +} + +void APIPCamera::setFocusAperture(float focus_aperture) +{ + camera_->CurrentAperture = focus_aperture; + copyCameraSettingsToAllSceneCapture(camera_); +} + +void APIPCamera::enableFocusPlane(bool enable) +{ + camera_->FocusSettings.bDrawDebugFocusPlane = enable; +} + +std::string APIPCamera::getCurrentFieldOfView() const +{ + std::ostringstream field_of_view_string; + field_of_view_string << "Current Field Of View:\n\tHorizontal Field Of View: " << camera_->GetHorizontalFieldOfView() << ";\n\t Vertical Field Of View: " << camera_->GetVerticalFieldOfView(); + return field_of_view_string.str(); +} + +void APIPCamera::copyCameraSettingsToAllSceneCapture(UCameraComponent* camera) +{ + int image_count = static_cast(Utils::toNumeric(ImageType::Count)); + for (int image_type = image_count - 1; image_type >= 0; image_type--) { + copyCameraSettingsToSceneCapture(camera_, captures_[image_type]); + } +} + +void APIPCamera::copyCameraSettingsToSceneCapture(UCameraComponent* src, USceneCaptureComponent2D* dst) +{ + if (src && dst) { + dst->SetWorldLocationAndRotation(src->GetComponentLocation(), src->GetComponentRotation()); + dst->FOVAngle = src->FieldOfView; + + FMinimalViewInfo camera_view_info; + src->GetCameraView(/*DeltaTime =*/0.0f, camera_view_info); + + const FPostProcessSettings& src_pp_settings = camera_view_info.PostProcessSettings; + FPostProcessSettings& dst_pp_settings = dst->PostProcessSettings; + + FWeightedBlendables dst_weighted_blendables = dst_pp_settings.WeightedBlendables; + + // Copy all of the post processing settings + dst_pp_settings = src_pp_settings; + + // But restore the original blendables + dst_pp_settings.WeightedBlendables = dst_weighted_blendables; + } +} + +//end CinemAirSim methods diff --git a/Unreal/Plugins/AirSim/Source/PIPCamera.h b/Unreal/Plugins/AirSim/Source/PIPCamera.h index fd4baad6ee..a50fefe552 100644 --- a/Unreal/Plugins/AirSim/Source/PIPCamera.h +++ b/Unreal/Plugins/AirSim/Source/PIPCamera.h @@ -11,13 +11,17 @@ #include "NedTransform.h" #include "DetectionComponent.h" +//CinemAirSim +#include +#include + #include "Materials/MaterialParameterCollection.h" #include "Materials/MaterialParameterCollectionInstance.h" #include "Materials/MaterialInstanceDynamic.h" #include "PIPCamera.generated.h" UCLASS() -class AIRSIM_API APIPCamera : public ACameraActor +class AIRSIM_API APIPCamera : public ACineCameraActor //CinemAirSim { GENERATED_BODY() @@ -26,7 +30,7 @@ class AIRSIM_API APIPCamera : public ACameraActor typedef msr::airlib::AirSimSettings AirSimSettings; typedef AirSimSettings::CameraSetting CameraSetting; - APIPCamera(); + APIPCamera(const FObjectInitializer& ObjectInitializer); //CinemAirSim virtual void PostInitializeComponents() override; virtual void BeginPlay() override; @@ -39,6 +43,25 @@ class AIRSIM_API APIPCamera : public ACameraActor void disableMain(); void onViewModeChanged(bool nodisplay); + //CinemAirSim methods + std::vector getPresetLensSettings() const; + void setPresetLensSettings(std::string preset_string); + std::vector getPresetFilmbackSettings() const; + void setPresetFilmbackSettings(std::string preset_string); + std::string getLensSettings() const; + std::string getFilmbackSettings() const; + float setFilmbackSettings(float sensor_width, float sensor_height); + float getFocalLength() const; + void setFocalLength(float focal_length); + void enableManualFocus(bool enable); + float getFocusDistance() const; + void setFocusDistance(float focus_distance); + float getFocusAperture() const; + void setFocusAperture(float focus_aperture); + void enableFocusPlane(bool enable); + std::string getCurrentFieldOfView() const; + //end CinemAirSim methods + void setCameraTypeEnabled(ImageType type, bool enabled); bool getCameraTypeEnabled(ImageType type) const; void setCaptureUpdate(USceneCaptureComponent2D* capture, bool nodisplay); @@ -72,8 +95,9 @@ class AIRSIM_API APIPCamera : public ACameraActor UPROPERTY() TArray detections_; + //CinemAirSim UPROPERTY() - UCameraComponent* camera_; + UCineCameraComponent* camera_; //TMap noise_materials_; //below is needed because TMap doesn't work with UPROPERTY, but we do have -ve index UPROPERTY() @@ -106,5 +130,9 @@ class AIRSIM_API APIPCamera : public ACameraActor void setNoiseMaterial(int image_type, UObject* outer, FPostProcessSettings& obj, const NoiseSetting& settings); void setDistortionMaterial(int image_type, UObject* outer, FPostProcessSettings& obj); static void updateCameraPostProcessingSetting(FPostProcessSettings& obj, const CaptureSetting& setting); - static void updateCameraSetting(UCameraComponent* camera, const CaptureSetting& setting, const NedTransform& ned_transform); + //CinemAirSim + static void updateCameraSetting(UCineCameraComponent* camera, const CaptureSetting& setting, const NedTransform& ned_transform); + void copyCameraSettingsToAllSceneCapture(UCameraComponent* camera); + void copyCameraSettingsToSceneCapture(UCameraComponent* src, USceneCaptureComponent2D* dst); + //end CinemAirSim }; diff --git a/Unreal/Plugins/AirSim/Source/WorldSimApi.cpp b/Unreal/Plugins/AirSim/Source/WorldSimApi.cpp index 46cb6f4df0..c832051340 100644 --- a/Unreal/Plugins/AirSim/Source/WorldSimApi.cpp +++ b/Unreal/Plugins/AirSim/Source/WorldSimApi.cpp @@ -919,6 +919,88 @@ std::vector WorldSimApi::getImage(ImageCaptureBase::ImageType image_typ return std::vector(); } +//CinemAirSim +std::vector WorldSimApi::getPresetLensSettings(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getPresetLensSettings(); +} + +std::string WorldSimApi::getLensSettings(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getLensSettings(); +} + +void WorldSimApi::setPresetLensSettings(std::string preset, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setPresetLensSettings(preset); +} + +std::vector WorldSimApi::getPresetFilmbackSettings(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getPresetFilmbackSettings(); +} + +void WorldSimApi::setPresetFilmbackSettings(std::string preset, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setPresetFilmbackSettings(preset); +} + +std::string WorldSimApi::getFilmbackSettings(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getFilmbackSettings(); +} + +float WorldSimApi::setFilmbackSettings(float width, float height, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setFilmbackSettings(width, height); +} + +float WorldSimApi::getFocalLength(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getFocalLength(); +} + +void WorldSimApi::setFocalLength(float focal_length, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setFocalLength(focal_length); +} + +void WorldSimApi::enableManualFocus(bool enable, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->enableManualFocus(enable); +} + +float WorldSimApi::getFocusDistance(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getFocusDistance(); +} + +void WorldSimApi::setFocusDistance(float focus_distance, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setFocusDistance(focus_distance); +} + +float WorldSimApi::getFocusAperture(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getFocusAperture(); +} + +void WorldSimApi::setFocusAperture(float focus_aperture, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->setFocusAperture(focus_aperture); +} + +void WorldSimApi::enableFocusPlane(bool enable, const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->enableFocusPlane(enable); +} + +std::string WorldSimApi::getCurrentFieldOfView(const CameraDetails& camera_details) +{ + return simmode_->getCamera(camera_details)->getCurrentFieldOfView(); +} +//End CinemAirSim + void WorldSimApi::addDetectionFilterMeshName(ImageCaptureBase::ImageType image_type, const std::string& mesh_name, const CameraDetails& camera_details) { const APIPCamera* camera = simmode_->getCamera(camera_details); diff --git a/Unreal/Plugins/AirSim/Source/WorldSimApi.h b/Unreal/Plugins/AirSim/Source/WorldSimApi.h index e672fdb5f5..7174d89459 100644 --- a/Unreal/Plugins/AirSim/Source/WorldSimApi.h +++ b/Unreal/Plugins/AirSim/Source/WorldSimApi.h @@ -95,6 +95,25 @@ class WorldSimApi : public msr::airlib::WorldSimApiBase const std::string& vehicle_name, bool external) const override; virtual std::vector getImage(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) const override; + //CinemAirSim + virtual std::vector getPresetLensSettings(const CameraDetails& camera_details) override; + virtual std::string getLensSettings(const CameraDetails& camera_details) override; + virtual void setPresetLensSettings(std::string preset, const CameraDetails& camera_details) override; + virtual std::vector getPresetFilmbackSettings(const CameraDetails& camera_details) override; + virtual void setPresetFilmbackSettings(std::string preset, const CameraDetails& camera_details) override; + virtual std::string getFilmbackSettings(const CameraDetails& camera_details) override; + virtual float setFilmbackSettings(float width, float height, const CameraDetails& camera_details) override; + virtual float getFocalLength(const CameraDetails& camera_details) override; + virtual void setFocalLength(float focal_length, const CameraDetails& camera_details) override; + virtual void enableManualFocus(bool enable, const CameraDetails& camera_details) override; + virtual float getFocusDistance(const CameraDetails& camera_details) override; + virtual void setFocusDistance(float focus_distance, const CameraDetails& camera_details) override; + virtual float getFocusAperture(const CameraDetails& camera_details) override; + virtual void setFocusAperture(float focus_aperture, const CameraDetails& camera_details) override; + virtual void enableFocusPlane(bool enable, const CameraDetails& camera_details) override; + virtual std::string getCurrentFieldOfView(const CameraDetails& camera_details) override; + //end CinemAirSim + virtual void addDetectionFilterMeshName(ImageCaptureBase::ImageType image_type, const std::string& mesh_name, const CameraDetails& camera_details) override; virtual void setDetectionFilterRadius(ImageCaptureBase::ImageType image_type, float radius_cm, const CameraDetails& camera_details) override; virtual void clearDetectionMeshNames(ImageCaptureBase::ImageType image_type, const CameraDetails& camera_details) override;