carla 标签 - Gitee.com

0.9.11

* Improved the documentation for use with pandoc tool by converting html tags to their markdown equivalent   * Refactored FAQ section of docs to use minimal html and fix broken layout   * Extended the local planner with a lateral `offset`   * Upgraded to DirectX 12 on Windows   * Added the new core pipeline for the simulator   * Added parameter to carla settings to control culling   * Added fully deterministic option for Traffic Manager, sorting vehicles by ID and avoiding race conditions   * Added the option to sweep the wheel shape for collision. This requires to patch the engine   * Added the possibility of changing physics substepping options from client   * Added 'noise_seed' to sensors to initialize the random generators   * API extensions:     - Added `actor.set_enable_gravity()` function to enable/disable the gravity affecting the actor     - Added `load_map_layer` and `unload_map_layer` to control map layers on new maps that support subleveling     - Added `get_environment_objects`call to get all the placed objects in the level     - Added `enable_environment_objects`call to enable/disable objects of the level     - Added `horizontal_fov` parameter to lidar sensor to allow for restriction of its field of view     - Added `WorldSettings.deterministic_ragdolls` to enable deterministic or physically based ragdolls   * Fixed RSSSensor python3 build and import of open drive maps by updating to ad-rss v4.2.0 and ad-map-access v2.3.0.    * Python import of dependent 'ad' python modules reflects now the namespaces of the C++ interface and follow doxygen documentation   * Fixed sensor transformations and sensor data transformations mismatch in IMU and camera-based sensors   * Fixed random dead-lock on synchronous mode at high frame rate   * Fixed bug on Windows causing sun reflection artifacts   * Fixed bug in `waypoint.get_landmarks()` causing some landmarks to be missed when s = 0   * Fixed the `actor.set_simulate_physics()` for pedestrians and vehicles   * Fixed bug causing camera-based sensors to stop sending data   * Fixed the lack of determinism on the output of raycast sensors   * Fixed missing `laneChange` record in converted OSM maps   * Fixed bug in the actor's id returned by the semantic lidar   * Fixed error when using `--config` parameter in `make package`   * Fixed dependency of library **Xerces-c** on package   * Fixed minor typo in the simulation data section of the documentation   * Fixed the `config.py` to read the `.osm ` files in proper `utf-8` encoding

78e7ea1

2020-12-23 06:54

下载

0.9.10.1

0c97e9a

2020-10-01 02:22

下载

0.9.10

* Added retrieval of bounding boxes for all the elements of the level   * Added deterministic mode for Traffic Manager   * Added support in Traffic Manager for dead-end roads   * Upgraded CARLA Docker image to Ubuntu 18.04   * Upgraded to AD RSS v4.1.0 supporting unstructured scenes and pedestrians, and fixed spdlog to v1.7.0   * Changed frozen behavior for traffic lights. It now affects to all traffic lights at the same time   * Added new pedestrian models   * API changes:     - Renamed `actor.set_velocity()` to `actor.set_target_velocity()`     - Renamed `actor.set_angular_velocity()` to `actor.set_target_velocity()`     - RGB cameras `exposure_mode` is now set to `histogram` by default   * API extensions:     - Added `carla.Osm2Odr.convert()` function and `carla.Osm2OdrSettings` class to support Open Street Maps to OpenDRIVE conversion     - Added `world.freeze_all_traffic_lights()` and `traffic_light.reset_group()`     - Added `client.stop_replayer()` to stop the replayer     - Added `world.get_vehicles_light_states()` to get all the car light states at once     - Added constant velocity mode (`actor.enable_constant_velocity()` / `actor.disable_constant_velocity()`)     - Added function `actor.add_angular_impulse()` to add angular impulse to any actor     - Added `actor.add_force()` and `actor.add_torque()`     - Added functions `transform.get_right_vector()` and `transform.get_up_vector()`     - Added command to set multiple car light states at once     - Added 4-matrix form of transformations   * Added new semantic segmentation tags: `RailTrack`, `GuardRail`, `TrafficLight`, `Static`, `Dynamic`, `Water` and `Terrain`   * Added fixed ids for street and building lights   * Added vehicle light and street light data to the recorder   * Improved the colliders and physics for all vehicles   * All sensors are now multi-stream, the same sensor can be listened from different clients   * New semantic LiDAR sensor (`lidar.ray_cast_semantic`)   * Added `open3D_lidar.py`, a more friendly LiDAR visualizer   * Added make command to download contributions as plugins (`make plugins`)   * Added a warning when using SpringArm exactly in the 'z' axis of the attached actor   * Improved performance of raycast-based sensors through parallelization   * Added an approximation of the intensity of each point of the cloud in the LiDAR sensor   * Added Dynamic Vision Sensor (DVS) camera based on ESIM simulation http://rpg.ifi.uzh.ch/esim.html   * Improved LiDAR and radar to better match the shape of the vehicles   * Added support for additional TraCI clients in Sumo co-simulation   * Added script example to synchronize the gathering of sensor data in client   * Added default values and a warning message for lanes missing the width parameter in OpenDRIVE   * Added parameter to enable/disable pedestrian navigation in standalone mode   * Improved mesh partition in standalone mode   * Added Renderdoc plugin to the Unreal project   * Added configurable noise to LiDAR sensor   * Replace deprecated `platform.dist()` with recommended `distro.linux_distribution()`   * Improved the performance of capture sensors   * Fixed the center of mass for vehicles   * Fixed a number of OpenDRIVE parsing bugs   * Fixed vehicles' bounding boxes, now they are automatic   * Fixed a map change error when Traffic Manager is in synchronous mode   * Fixes add entry issue for applying parameters more than once in Traffic Manager   * Fixes std::numeric_limits<float>::epsilon error in Traffic Manager   * Fixed memory leak on `manual_control.py` scripts (sensor listening was not stopped before destroying)   * Fixed a bug in `spawn_npc_sumo.py` script computing not allowed routes for a given vehicle class   * Fixed a bug where `get_traffic_light()` would always return `None`   * Fixed recorder determinism problems   * Fixed several untagged and mistagged objects   * Fixed rain drop spawn issues when spawning camera sensors   * Fixed semantic tags in the asset import pipeline   * Fixed `Update.sh` from failing when the root folder contains a space on it   * Fixed dynamic meshes not moving to the initial position when replaying   * Fixed colors of lane markings when importing a map, they were reversed (white and yellow)   * Fixed missing include directive in file `WheelPhysicsControl.h`   * Fixed gravity measurement bug from IMU sensor   * Fixed LiDAR’s point cloud reference frame   * Fixed light intensity and camera parameters to match   * Fixed and improved auto-exposure camera (`histogram` exposure mode)   * Fixed delay in the TCP communication from server to the client in synchronous mode for Linux   * Fixed large RAM usage when loading polynomial geometry from OpenDRIVE   * Fixed collision issues when `debug.draw_line()` is called   * Fixed gyroscope sensor to properly give angular velocity readings in the local frame   * Fixed minor typo in the introduction section of the documentation   * Fixed a bug at the local planner when changing the route, causing it to maintain the first part of the previous one. This was only relevant when using very large buffer sizes

c7b2076

2020-09-26 03:24

下载

0.9.9.4

baf43b0

2020-06-18 21:48

下载

0.9.9.3

f114dc0

2020-06-15 16:53

下载

0.9.9.2

4dc4cb8

2020-05-21 17:27

下载

0.9.9.1

09ec923

2020-05-14 16:05

下载

0.9.9

* Introduced hybrid mode for Traffic Manager
  * Upgraded to Unreal Engine 4.24
  * Fixed autonomous agents' incorrect detection of red traffic lights affecting them
  * Improved manual_control by adding realistic throttle and brake
  * Added walkable pedestrian crosswalks in OpenDRIVE standalone mode
  * Improved mesh generation with a chunk system for better performance and bigger maps in the future
  * Added security features to the standalone OpenDRIVE mode aiming to prevent cars from falling down from the road
  * Added junction smoothing algorithm to prevent roads from blocking other roads with level differences
  * Added new Behavior agent
  * Added automatic generation of traffic lights, stop signal and yield signal from OpenDRIVE file
  * Upgraded to AD RSS v3.0.0 supporting complex road layouts and i.e. intersections
  * Added examples of sumo co-simulation for Town01, Town04 and Town05
  * Added ptv vissim and carla co-simulation
  * Fixed `GetLeftLaneMarking()` from a possible runtime error
  * API extensions:
    - Added new methods to `Map`: `get_all_landmarks`, `get_all_landmarks_from_id` and `get_all_landmarks_of_type`
  * Added synchronization of traffic lights in sumo co-simulation
  * Added light manager to control the lights of the map.

1a2c2ea

2020-04-23 21:52

下载

0.9.8

e9dd27f

2020-03-09 23:36

下载

0.9.7

* Upgraded parameters of Unreal/CarlaUE4/Config/DefaultInput.ini to prevent mouse freeze
  * Add build variant with AD RSS library integration with RSS sensor and result visualisation
  * Support for OpenGL and Vulkan in docker + headless mode
  * Added new sensor: Inertial measurement unit (IMU)
  * Added new sensor: Radar
  * Exposed rgb camera attributes: exposure, depth of field, tonemapper, color correction, and chromatic aberration
  * Now all the camera-based sensors are provided with an additional parametrized lens distortion shader
  * Added TrafficManager to replace autopilot in managing the NPC vehicles
  * Improved pedestrians navigation
  * API changes:
    - Lidar: `range` is now set in meters, not in centimeters
    - Lidar: `horizontal_angle` is now received in radians, not in degrees
    - GNSS: `carla.GnssEvent` renamed to `carla.GnssMeasurement`
  * API extensions:
    - Added `carla.IMUMeasurement`
    - Added `carla.RadarMeasurement` and `carla.RadarDetection`
    - GNSS data can now be obtained with noise
    - IMU data can now be obtained with noise
  * Moved GNSS sensor from client to server side
  * Added exporter plugin for UE4 to allow export meshes ready for Recast calculation
  * The 'make import' process now rename the assets accordingly and set complex collision as simple
  * New Python API function added (map.get_crosswalks()) that returns a list with all points that define the crosswalk zones from OpenDRIVE file
  * Updated `manual_control.py` with a lens disortion effect example
  * Updated `manual_control.py` with IMU and Radar realtime visualization
  * Fixed pylint for python3 in travis
  * Fixed PointCloudIO `cout` that interfiered with other python modules
  * Better steering in manual control
  * Added Doxygen documentation online with automatic updates through Jenkins pipeline
  * Fixed an error in `automatic_control.py` failing because the `Num Lock` key
  * Fixed client_bounding_boxes.py example script
  * Fixed materials and semantic segmentation issues regarding importing assets
  * Fixed ObstacleSensor to return HitDistance instead of HitRadius

b9fbbf7

2019-12-21 11:59

下载

0.9.6

ARLA 0.9.6

* Upgraded to Unreal Engine 4.22
  * Added Vulkan support, if installed, CARLA will use Vulkan, use `-opengl` flag to launch with OpenGL
  * The simulator is now compiled in "Shipping" mode, faster but it accepts less command-line arguments
  * Pedestrians are back:
    - Spawn pedestrians that will roam randomly on sidewalks
    - The script 'spawn_npc.py' spawns now pedestrians, adjust the number with the flag `-w`
    - Added navigation meshes for each maps for pedestrian navigation
  * Allow adding custom props (FBX) to CARLA Blueprint library so they are spawnable
  * Simplified pipeline for importing and packaging maps and custom props
  * Vehicle physics:
    - Added access to vehicle transmission details
    - Added access to vehicle physics brake values
    - Added tire friction trigger boxes for simulating slippery surfaces
  * Added camera gamma correction as command-line argument to manual_control.py
  * Added ability to set motion blur settings for RGB camera in sensor python blueprint
  * Added C++ client example using LibCarla
  * Added PythonAPI documentation generator, we documented in detail all the Python reference
  * Added a new Python script config.py that allows the user to configure the simulator from the command-line
  * New recorder features:
    - Documented recorded system and binary file
    - Added optional parameter to show more details about a recorder file (related to `show_recorder_file_info.py`)
    - Added playback speed (slow/fast motion) to the replayer
    - Allow custom paths for saving the recorded files
    - More data is now recorded to replay animations:
      + Wheels of vehicles are animated (steering, throttle, handbrake), also bikes and motorbikes
      + Walker animations are simulated (through speed of walker)
  * New high quality pedestrians: female, girl and boy; improved meshes and textures
  * More color and texture variations for each pedestrian
  * New vehicle Audi Etron: 25.000 tris and LODs
  * New material for Mustang, new system that will allow us to improve all the vehicle materials
  * Improved vehicle Tesla
  * New high-quality "Default" weather tailor-made for each map
  * Improved the rest of weather profiles too
  * RGB camera improvements:
    - Enabled temporal antialiasing and motion blur
    - Added gamma value and motion blur as a blueprint attributes
    - Enabled texture streaming for scene captures
  * API changes:
    - Renamed `frame_count` and `frame_number` as `frame`, old members are kept as deprecated
    - `world.wait_for_tick()` now returns a `carla.WorldSnapshot`
    - The callback of `world.on_tick(callback)` now receives a `carla.WorldSnapshot`
    - Deprecated waypoint's `is_intersection`, use `is_junction` instead
  * API extensions:
    - Added attachment type "SpringArm" for cinematic cameras
    - Added waypoint's `junction_id` that returns de OpenDrive identifier of the current junction
    - Added `world.get_actor(id)` to find a single actor by id
    - Added `carla.WeatherParameters.Default` for the default (tailor-made for each town) weather profile
    - Added `WorldSnapshot` that contains a list of `ActorSnapshot`, allows capturings a "still image" of the world at a single frame
    - Added `world.tick()` now synchronizes with the simulator and returns the id of the newly started frame
    - Added `world.apply_settings(settings)` now synchronizes with the simulator and returns the id of the frame when the settings took effect
    - Added `world.remove_on_tick(id)` to allow removing on tick callbacks
    - Added allow setting fixed frame-rate from client-side, now is part of `carla.WorldSettings`
    - Added `is_invincible` to walkers
  * Several optimizations to the RPC server, now supports a bigger load of async messages
  * Updated DebugHelper to render on Shipping packages, it has also better performance
  * Updated OpenDriveActor to use the new Waypoint API
  * Removed deprecated code and content
  * Exposed waypoints and OpenDrive map to UE4 Blueprints
  * Change the weight of cars. All cars have been compared with the real to have a feedback more real
  * Recorder fixes:
    - When a recorded session finish replaying, all vehicles will continue in autopilot, and all pedestrians will stop
    - Fixed a possible crash if an actor is respawned before the episode is ready when a new map is loaded automatically
    - Actors at start of playback could interpolate positions from its current position instead than the recorded position
    - Camera following in playback was not working if a new map was needed to load
    - API function 'show_recorder_file_info' was showing the wrong parent id
    - Script 'start_recording.py' now properly saves destruction of actors at stop
    - Problem when vehicles enable autopilot after a replayer, now it works better
  * Fixed dead-lock when loading a new map in synchronous mode
  * Fixed get_actors may produce actors without parent
  * Fixed std::bad_cast when importing other libraries, like tensorflow, before carla
  * Fixed latitude in WGS84 reprojection code such that Latitudes increase as one move north in CARLA worlds
  * Fixed walking animations, the animations now go at the same speed as the game
  * Fixed loading and reloading world not using the timeout
  * Fixed XODR files can be found now anywhere in content
  * Fixed bug related with Pygame error of surface too large, added sidewalks and improved lane markings in `no_rendering_mode.py`
  * Fixed Lidar effectiveness bug in manual_control.py
  * Fixed wrong units in VehiclePhysicsControl's center of mass
  * Fixed semantic segmentation of bike riders
  * Fixed inconsistent streetlights in Town03
  * Fixed incorrect vehicle bounds

e2c4dc1

2019-07-11 17:45

下载

0.9.5

CARLA 0.9.5

* New Town07, rural environment with narrow roads
  * Reworked OpenDRIVE parser and waypoints API
    - Fixed several situations in which the XODR was incorrectly parsed
    - Exposed more information: lane marking, lane type, lane section id, s
    - API change: waypoint's `lane_type` is now an enum, `carla.LaneType`
    - API change: `carla.LaneMarking` is not an enum anymore, extended with color, type, lane change, and width
    - API extension: `map.get_waypoint` accepts an extra optional flag argument `lane_type` for filtering lane types
    - API extension: `carla.Map` can be constructed off-line out of XODR files, `carla.Map(town_name, xodr_content)`
    - API extension: `id` property to waypoints, uniquely identifying waypoints up to half centimetre precision
  * API change: Renamed "lane_invasion" to "lane_detector", added too its server-side sensor to be visible to other clients
  * API extension: new carla.command.SpawnActor to spawn actors in batch
  * API extension: `map.transform_to_geolocation` to transform Location to GNSS GeoLocation
  * API extension: added timestamp (elapsed simulation seconds) to SensorData
  * API extension: method `client.apply_batch_sync` that sends commands in batch and waits for server response
  * API extension: optional argument "actor_ids" to world.get_actors to request only the actors with the ids provided
  * Migrated Content to AWS
  * Updated `spawn_npc.py` to spawn vehicles in batch
  * Added --rolename to "manual_control.py"
  * Added options to "no_rendering_mode.py" to draw extra road information
  * Added "scene_layout.py" to retrieve the whole information in the scene as Python dict
  * Basic agent integrated with global router
  * Allow usage of hostname for carla::Client and resolve them to IP addresses
  * Added new pack of assets
    - Windmill, different farm houses, silo
    - Plants corn, dandelion, poppy, and grass
    - Yield traffic sign
  * Added modular buildings New York style
  * Added marking lanes in Town03
  * Added command-line arguments to simulator to disable rendering and set the server timeout
  * Improved performance in Town01 and Town02
  * Changed yellow marking lane from Town01 and Town02 to dashed yellow marking lane
  * Improved lane cross detection to use the new Waypoint API
  * Enhanced stop triggers options
  * Fixed semantic segmentation tags in Town04, Town05, Town06
  * Fixed tree collision in Town01
  * Fixed VehicleSpawnPoint out of the road in Town01
  * Fixed geo-reference of Town01 and Town07
  * Fixed floating pillars in Town04
  * Fixed floating building in Town03
  * Fixed vehicles missing the route if autopilot enabled too late
  * Fixed division by zero in is_within_distance_ahead()
  * Fixed local planner to avoid premature route pruning at path overlaps
  * Fixed global router behavior to be consistent with new Waypoint API
  * Fixed clean up of local_planner when used by other modules
  * Fixed python client DLL error on Windows
  * Fixed wrong type returned by `ActorList.Filter(...)`
  * Fixed wheel's tire friction affecting all vehicles from physics control parameters
  * Fixed obstacle detector not working
  * Fixed small float bug in misc.py

1b8fe4c

2019-04-02 00:50

下载

0.9.4

CARLA 0.9.4

* Added recording and playback functionality
  * Added synchronous mode, simulator waits until a client sends a "tick" cue, `client.tick()`
  * Allow changing map from client-side, added `client.load_map(name)`, `client.reload_map()`, and `client.get_available_maps()`
  * Added scripts and tools to import maps directly from .fbx and .xodr files into the simulator
  * Exposed minimum physics control parameters for vehicles' engine and wheels
  * Allow controlling multiple actors in "batch mode"
  * New Town06, featuring a "Michigan left" intersection including:
    - Connection ramp between two highways
    - Incorporation to a highway requiring changing several lanes to take another exit
    - Junctions supporting different scenarios
  * New traffic signs assets: one-way, no-turn, more speed limits, do not enter, arrow floors, Michigan left, and lane end
  * New pedestrian texture to add more variations
  * New road PBR material
  * Extended the waypoint API with `lane_change`, `lane_type`, `get_right_lane()` and `get_left_lane()`
  * Added world settings for changing no-rendering mode and synchronous mode at run-time
  * Added methods to acquire a traffic light's pole index and all traffic lights in it's group
  * Added performance benchmark script to measure the simulator's rendering performance
  * Added `manual_control_steeringwheel.py` to control agents using Logitech G29 steering wheels (and maybe others)
  * Added movable props present in the map (e.g. chairs and tables) as actors so they can be controlled from Python
  * Added recording and playback bindings to `manual_control.py` script
  * Removed `world.map_name` from API, use `world.get_map().name` instead
  * Refactored `no_rendering_mode.py` to improve performance and interface
  * Several improvements to the build system for Windows
  * Expose traffic sign's trigger volumes on Python API
  * Improved export/import map tools
  * Simplify Dockerfile halving Carla Docker image size
  * Episodes have now a random unique id to avoid collisions between runs
  * Reduced overhead of many RPC calls by sending only actor IDs (instead of serializing all the actor attributes every time)
  * Added priority system for vehicle control input (internal, not exposed in API)
  * Removed "Example.CarlaSettings.ini", you can still use it, but it's no longer necessary
  * Improved time-out related error messages
  * Fixed Town01 placed 38 meters above the zero
  * Fixed parsing of OpenDrive geo-reference exported by RoadRunner
  * Fixed issue of retrieving an empty list when calling `world.get_actors()` right after creating the world
  * Fixed a few synchronization issues related to changing the world at runtime
  * Fixed traffic light when it gets illuminated by the hero vehicle in `no_rendering_mode.py`
  * Fixed `manual_control.py` and `no_rendering_mode.py` to prevent crashes when used in "no rendering mode"
  * Fixed traffic signs having the trigger box rotated
  * Fixed female walk animation
  * Fixed BP_MultipleFloor, tweaked offset in BaseFloor to adjust meshes between them
  * Fixed static objects present in the map were marked as "movable"

cf1598a

2019-03-02 01:52

下载

0.9.3

CARLA 0.9.3

* Upgraded to Unreal Engine 4.21
  * Upgraded Boost to 1.69.0
  * New Town04 (biggest so far), includes a freeway, new bridge and road barrier, a nicer landscape based on height-map, and new street props
  * New Town05, adding more variety of intersections for the scenario runner
  * Redesigned pedestrian models and animations (walk and idle) for male and female characters
  * Added sensor for detecting obstacles (ray-cast based)
  * Added sensor GNSS (GPS)
  * Basic agent integrated with global router
  * Added a few methods to manage an actor:
    - set_velocity: for setting the linear velocity
    - set_angular_velocity: for setting the angular velocity
    - get_angular_velocity: for getting the angular velocity
    - add_impulse: for applying an impulse (in world axis)
  * Renamed vehicle.get_vehicle_control() to vehicle.get_control() to be consistent with walkers
  * Added new mesh for traffic lights
  * Added new pine tree assets, with their LODs finely tuned for performance
  * Added point transformation functionality for LibCarla and PythonAPI
  * Added "sensor_tick" attribute to sensors (cameras and lidars) to specify the capture rate in seconds
  * Added Export/Import map tools
  * Added "get_forward_vector()" to rotation and transform, retrieves the unit vector on the rotation's X-axis
  * Added support for Deepin in PythonAPI's setup.py
  * Added support for spawning and controlling walkers (pedestrians)
  * Updated BasicAgent to allow setting target_speed and handle US-style traffic lights properly
  * OpenDriveActor has been rewritten using the Waypoint API, this has fixed some bugs
  * Remove crash reporter from packaged build
  * Improved simulator fatal error handling, now uses UE4 fatal error system
  * LibCarla server pipeline now compiles with exceptions disabled for better performance and compatibility with UE4
  * Fixed TCP accept error, too many open files while creating and destroying a lot of sensors
  * Fixed lost error messages in client-side, now when a request fails it reports the reason
  * Fixed global route planner to handle round about turns and made the code consistent with local planner
  * Fixed local planner to avoid premature route pruning at path overlaps
  * Fixed autopilot direction not properly initialized that interfered with the initial raycast direction
  * Fixed crash when an actor was destroyed but not de-registered, e.g. falling out of world bounds

9134973

2019-01-31 21:28

下载

0.9.2

CARLA 0.9.2

* Updated ROS bridge for CARLA 0.9.X (moved to its own repository)
  * Added Python API "agents" extension, includes
    - Global route planner based on the Waypoints API (compatible with OpenDrive)
    - BasicAgent: new client agent that can drive to a given coordinate of the map using the waypoint API and PID controllers, attending to other vehicles and traffic lights
    - RoamingAgent: new client agent that can drive at different speeds following waypoints based on PID controllers, attending to other vehicles and traffic lights
    - LocalPlanner functionality to navigate waypoints using PID controllers
    - LateralControl and LongitudinalControl PIDs
  * Add support for manual gear shifting
  * Add "role_name" attribute to actors to easily identify the "hero" vehicle
  * Updates to documentation and tutorials
  * Simulator now starts by default in windowed mode
  * CMake version required downgraded to 3.5 for better compatibility
  * Fix waypoints height were all placed at zero height
  * Fix actors in world.get_actors() missing parent actor
  * Fix some vehicles losing their wheels after calling set_simulate_physics
  * Several fixes and improvements to OpenDriveActor

c7759ef

2018-12-22 06:14

下载

0.9.1

CARLA 0.9.1

* New town: Town03
    - Created with Vector Zero's RoadRunner (including OpenDrive information of the road layout)
    - Bigger and more diverse
    - More road variety: multiple lanes and lane markings, curves at different angles, roundabout, elevation, tunnel
  * Lots of improvements to the Python API
    - Support for Python 3
    - Support for retrieving and changing lighting and weather conditions
    - Migrated Lidar sensor
    - Migrated image converter methods: Depth, LogarithmicDepth, and CityScapesPalette
    - Migrated IO methods for sensor data, "save_to_disk" available for PNG, JPEG, TIFF, and PLY
    - Added support for requesting the list of all the actors alive in the current world, `world.get_actors()`
    - `world.get_actors()` returns an `ActorList` object with `filter` functionality and lazy initialization of actors
    - Added collision event sensor, "sensor.other.collision", that triggers a callback on each collision to the actor it is attached to
    - Added lane detector sensor, "sensor.other.lane_detector", that detects lane invasion events
    - Added `carla.Map` and `carla.Waypoint` classes for querying info about the road layout
      - Added methods for converting and saving the map as OpenDrive format
      - Added `map.get_spawn_points()` to retrieve the recommended spawn points for vehicles
      - Added `map.get_waypoint(location)` to query the nearest waypoint
      - Added `map.generate_waypoints(distance)` to generate waypoints all over the map at an approximated distance
      - Added `map.get_topology()` for getting a list the tuples of waypoints that define the edges of the road graph
      - Added `waypoint.next(distance)` to retrieve the list of the waypoints at a distance that can be driven from this waypoint
    - Added `parent` attributes to actors, not None if the actor is attached to another actor
    - Added `semantic_tags` to actors containing the list of tags of all of its components
    - Added methods for retrieving velocity and acceleration of actors
    - Added function to enable/disable simulating physics on an actor, `actor.set_simulate_physics(enabled=True)`
    - Added bounding boxes to vehicles, `vehicle.bounding_box` property
    - Exposed last control applied to vehicles, `vehicle.get_vehicle_control()`
    - Added a "tick" message containing info of all the actors in the scene
      - Executed in the background and cached
      - Added `world.wait_for_tick()` for blocking the current thread until a "tick" message is received
      - Added `world.on_tick(callback)` for executing a callback asynchronously each time a "tick" message is received
      - These methods return/pass a `carla.Timestamp` object containing, frame count, delta time of last tick, global simulation time, and OS timestamp
      - Methods retrieving actor's info, e.g. `actor.get_transform()`, don't need to connect with the simulator, which makes these calls quite cheap
    - Allow drawing debug shapes from Python: points, lines, arrows, boxes, and strings (`world.debug.draw_*`)
    - Added id (id of current episode) and map name to `carla.World`
    - Exposed traffic lights and signs as actors. Traffic lights have a specialized actor class that has the traffic light state (red, green, yellow) as property
    - Added methods for accessing and modifying individual items in `carla.Image` (pixels) and `carla.LidarMeasurement` (locations)
    - Added `carla.Vector3D` for (x, y, z) objects that are not a `carla.Location`
    - Removed `client.ping()`, `client.get_server_version()` accomplishes the same
    - Renamed `contains_X()` methods to `has_X()`
    - Changed `client.set_timeout(seconds)` to use seconds (float) instead of milliseconds
    - Allow iterating attributes of an Actor's Blueprint
    - Fixed wildcard filtering issues, now "vehicle.*" or "*bmw*" patterns work too
    - Fixed `actor.set_transform()` broken for attached actors
  * More Python example scripts and improved the present ones
    - Now all the scripts use the list of recommended spawn points for each map
    - Renamed "example.py" to "tutorial.py", and updated it with latest changes in API
    - Added timeout to the examples
    - "manual_control.py" performance has been improved while having more measurements
    - "manual_control.py" now has options to change camera type and position
    - "manual_control.py" now has options to iterate weather presets
    - "manual_control.py" now has a fancier HUD with lots of info, and F1 key binding to remove it
    - Added "dynamic_weather.py" to change the weather in real-time (the one used in the video)
    - Added "spawn_npc.py" to quickly add a lot of NPC vehicles to the simulator
    - Added "spawn_npc.py --safe" to only add non-problematic vehicles
    - "vehicle_gallery.py" also got some small fixes
  * Asset and content improvements
    - New vehicle: Lincoln MKZ 2017
    - Refactored weather system, parametrized to make it easier to use
    - Improved control of bikes and motorbikes, still not perfect but causes less accidents
    - Added building block generator system
    - Misc city assets: New building, tunnel columns, rail-road bridges, new textures, new urban props
    - Adjusted vehicle physics and center of mass
    - Adjusted the maximum distance culling for foliage
    - Adjusted pedestrian animations and scale issues (not yet available with new API though)
    - Improved map building blueprints, spline based asset repeaters, and wall building tools
    - Replaced uses of Unreal's Foliage system with standard static meshes to work around a visual bug in Linux systems
    - Fixed filenames too long when packing the project on Windows
    - Fixed "SplineMeshRepeater" loses its collider mesh from time to time
    - Standardized asset nomenclature
  * New system for road information based on OpenDrive format
    - Added new map classes for querying info about the road layout and topology
    - Added methods for finding closest point on the road
    - Added methods for generating and iterating waypoints based on the road layout
    - Added OpenDrive parser to convert OpenDrive files to our map data structures
  * Other miscellaneous improvements and fixes
    - Fixed single channel Lidar crash (by @cwecht)
    - Fixed command-line argument `-carla-settings` fails to load absolute paths (by @harlowja)
    - Added an option to command-line to change quality level when launching the simulator, `-quality-level=Low`
    - Added ROS bridge odometry message (by @ShepelIlya)
    - New lens distortion shader, sadly not yet integrated with our cameras :(
    - New Docker tutorial
    - Disabled texture streaming to avoid issue of textures not loading in scene captures
    - Adjusted scene capture camera gamma to 2.4
    - Fixed leaking objects in simulation when despawning a vehicle. Now Pawn's controller is destroyed too if necessary when destroying an Actor
    - Fixed overflow on platform time-stamp, now it uses `double`
    - Upgraded @rpclib to fix crash when client exits too fast (rpclib/PR#167)
    - Moved "PythonClient" inside deprecated folder to avoid confusion
    - Refactored sensor related code
      - New plugin system for sensors that simplifies adding sensors, mini-tutorial at #830
      - Compile-time dispatcher for sensors and serializers
  * Improvements to the streaming library
    - Added multi-streams for streaming simultaneously to multiple clients (used by the "tick" message)
    - Messages re-use allocated memory when possible
    - Allows unsubscribing from a stream
    - Fixed client receives interleaved sensor messages, some messages can be discarded if connection is too slow though
    - Fixed streaming client fails to connect in Windows
    - Fixed streaming client keeps trying to reconnect after destroying a sensor
  * Refactored client C++ API
    - Python GIL is released whenever possible to avoid blocking
    - Fixed deadlock when closing the simulator while a client is connected
    - Fixed crash on simulator shutdown if a client has connected at some point
    - Set methods are now sent async which greatly improves performance in the client-side
    - Vehicle control is cached and not sent if haven't changed
    - Suppressed exceptions in destructors
  * Other development improvements
    - Improved Linux Makefile, fine-grained targets to reduce compilation times in development
    - Workaround for "setup.py" to link against "libcarla_client.a" again (Linux only)
    - Added support for ".gtest" file, each line of this file is passed to GTest executables as arguments when running `make check` targets
    - Python eggs are also archived on Jenkins to easily get them without downloading the full package
    - Added uncrustify config file for formatting UE4 C++ code

cddb982

2018-11-16 20:29

下载

0.9.0

CARLA 0.9.0

* Upgraded to Unreal Engine 4.19
  * Redesign of the networking architecture
    - Allows any number of clients to connect simultaneously
    - Now is possible to add and remove at any time any vehicle or camera
    - Now is possible to control any vehicle or camera
    - Now is possible to place cameras anywhere
    - Reduced to two ports instead of three
    - First port uses an RPC protocol based on [rpclib](http://rpclib.net/)
    - Second port is for the streaming of the sensor data
  * Redesign of the Python API
    - Actors and sensors are now exposed in the API and can be independently controlled
    - The Python module is built in C++, with significant performance gain in some operations
    - Many functionality haven't been ported yet, so expect a lot of things missing
  * Redesign of the build system to accommodate the changes in dependencies
    - Everything can be done now with the Makefile
    - For the moment only Linux is supported, sorry
  * Massive clean up of all unused assets
  * Some aesthetic fixes to the vehicles

20fc5a3

2018-07-30 20:28

下载

0.8.4

ab9a2c7

2018-06-16 00:57

下载

0.8.3

CARLA 0.8.3

* Added two-wheeled vehicles, 3 bicycles and 4 motorbikes
  * Several art optimizations (CARLA is now about 10% faster)
    - Improved the performance of vegetation assets, adjusted LOD and culling distance, set billboards where possible
    - Drastically reduced the number of polygons of the landscape while keeping the original shape
    - Removed some high-cost unnecessary assets
    - Remodelled Mustang and NissanMicra, now with less polygons and materials, better textures and LOD
    - Remodelled building SM_TerracedHouse_01, now with more polygons but less materials and better textures
  * CARLA releases include now a Dockerfile for building docker images
  * Change in HUD: replace "FPS" by "Simulation Step"
  * The current map name is now included in the scene description message sent to the client
  * Adapted "manual_control.py" and "view_start_positions.py" to use the map name sent by the simulator
  * Improved the vehicle spawning algorithm, now it tries to spawn as much cars as possible even if there are not enough spawn points
  * "Setup.sh" is now faster and accepts an argument to run multiple jobs in parallel
  * Fixed foliage distance culling using wrong distance in "Low Mode"
  * Fixed NissanMicra slightly turning left when driving straight

332d40b

2018-06-07 22:22

下载

0.8.2

CARLA 0.8.2

* Revamped driving benchmark
    - Changed name from benchmark to driving benchmark
    - Fully Redesigned the architecture of the module
    - Added a lot more documentation
    - Now you can stop and resume the benchmarks you run
  * Rolled back vehicle's location to the pivot of the mesh instead of the center of the bounding box
  * Added relative transform of the vehicle's bounding box to the measurements, player and non-players
  * Added "frame number" to each sensor measurement so it is possible to sync all the measurements based on the frame they are produced
  * Improved vehicle spawner to better handle spawning failures
  * Walkers use now a closer angle to detect vehicles, so they don't stop moving if a car passes nearby
  * Fixed lighting artefact causing the road to change its brightness depending on the distance to the camera
  * Fixed captured images overexposed in Low mode
  * Fixed illegal character in asset name
  * Fixed editing sun azimuth angle in CarlaWeadther.ini had no effect
  * Fixed crash when using a non-standard image size in DirectX (Windows)
  * Fixed issue with using multiple "SceneCaptureToDiskCamera"

2d52245

2018-04-23 16:57

下载

gelinhe/carla .gitee-modal { width: 500px !important; }

搜索帮助

gelinhe/carla