Sensor JSON Options
This page details the different available sensors and the configuration options possible.
Table of Contents
- Examples
- How to Specify a Sensor
- Clock
- Color Camera
- Depth Camera
- Segmentation Camera
- Lidar
- 3D Ground Truth
- 3D Ground Truth Visualizer
- CAN-Bus
- GPS Device
- GPS Odometry
- GPS-INS Status
- Vehicle Control
- Keyboard Control
- Wheel Control
- Manual Control
- Cruise Control
- IMU
- 2D Ground Truth
- 2D Ground Truth Visualizer
- Radar
- Ultrasonic
- Control Calibration
- Transform Sensor
- Signal Sensor
Examples top#
Example JSON configurations are available here:
- Apollo 5.0 JSON
- Apollo 3.0 JSON
- Autoware.AI
- Autoware.Auto
- Data Collection JSON
- Some Lidar sensor JSONs:
How to Specify a Sensor top#
A vehicle configuration is in the following format:
[
SENSOR,
SENSOR,
SENSOR
]
A SENSOR
is defined in the JSON configuration in the following format:
{
"type": STRING,
"name": STRING,
"params": {PARAMS},
"parent": STRING,
"transform": {
"x": FLOAT,
"y": FLOAT,
"z": FLOAT,
"pitch": FLOAT,
"yaw": FLOAT,
"roll": FLOAT,
}
}
type
is the type of sensor.name
is the name of the sensor. This is how the sensor will be identified.params
are the explicitly specified parameters. If a parameter is not set, the Default Value in the sensor definition will be used.- ex.
{"Width": 1920, "Height": 1080}
-
There are 2 parameters that all sensors have
Parameter Description Default Value Topic
defines the topic that the sensor will subscribe/publish to null
Frame
defines the frame_id if the sensor publishes a ROS message. See ROS Header Message for more information null
-
parent
(OPTIONAL) a sensor'stransform
can be relative to another sensor.STRING
is thename
of the base sensor transform to which this sensor is relative. -
If omitted, the
transform
is relative to the origin of the vehicle. transform
is the location and rotation of the sensor relative to the local position of the vehicle. The Unity left-hand coordinate system is used (+x right, +y up, +z forward, +pitch tilts the front down, +yaw rotates clockwise when viewed from above, +roll tilts the left side down).x
is the position of the sensor along the x-axisy
is the position of the sensor along the y-axisz
is the position of the sensor along the z-axispitch
is the rotation around the x-axisyaw
is the rotation around the y-axisroll
is the rotation around the z-axis
Clock top#
This sensor outputs simulated time to ROS as rosgraph_msgs/Clock message, or to CyberRT as clock message. The only parameter to use is topic/channel name.
For ROS, you can add <param name="/use_sim_time" value="true">
to their ROS launch file, or use rosparam set /use_sim_time true
in command line, to have a ROS node use simulation time according to the /clock
topic. For more details please refer to this page.
For CyberRT, you can set clock_mode
in cyber.pb.conf as MODE_MOCK
to have CyberRT use simulation time according to the /clock
topic.
{
"type": "Clock",
"name": "Clock Sensor",
"params": {
"Topic": "/clock"
}
}
Color Camera top#
This is the type of sensor that would be used for the Main Camera
in Apollo.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Width |
defines the width of the image output | pixels | Int | 1920 | 1 | 1920 |
Height |
defines the height of the image output | pixels | Int | 1080 | 1 | 1080 |
Frequency |
defines the maximum rate that messages will be published | Hertz | Int | 15 | 1 | 100 |
JpegQuality |
defines the quality if the image output | % | Int | 75 | 0 | 100 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 60 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor for it to be detected | meters | Float | 0.1 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor for it to be detected | meters | Float | 2000 | 0.01 | 2000 |
Distorted |
defines if the image is distorted | Bool | false |
|||
DistortionParameters |
parameters used by distortion * | List of Float | empty list | |||
Fisheye |
defines if the camera has fisheye lens | Bool | false |
|||
Xi |
parameter used by fisheye distortion ** | Float | 0.0 | |||
CubemapSize |
size of the cubemap used by fisheye distortion *** | pixels | Int | 1024 | 512 | 2048 |
* If Distorted
is true
, DistortionParameters
must be an empty list or a list of FOUR floats.
The values in this list should come from calibration result of real camera. Setting arbitrary values may cause undefined result.
If Distorted
is false
, DistortionParameters
, Fisheye
and Xi
are ignored.
** If Fisheye
is true
, Xi
should be a value from calibration result of real camera. Setting arbitrary value may cause undefined result.
If Fisheye
is false
, Xi
is ignored.
*** CubemapSize
should only be 512, 1024, or 2048.
{
"type": "Color Camera",
"name": "Main Camera",
"params": {
"Width": 1920,
"Height": 1080,
"Frequency": 15,
"JpegQuality": 75,
"FieldOfView": 50,
"MinDistance": 0.1,
"MaxDistance": 2000,
"Topic": "/simulator/main_camera",
"Frame": "camera",
"Distorted": true,
"DistortionParameters": [
-0.25349, 0.11868, 0, 0
]
},
"transform": {
"x": 0,
"y": 1.7,
"z": -0.2,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Depth Camera top#
This sensor returns an image where the shades on the grey-scale correspond to the depth of objects.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Width |
defines the width of the image output | pixels | Int | 1920 | 1 | |
Height |
defines the height of the image output | pixels | Int | 1080 | 1 | 1080 |
Frequency |
defines the maximum rate that messages will be published | Hertz | Int | 5 | 1 | 100 |
JpegQuality |
defines the quality if the image output | % | Int | 100 | 0 | 100 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 60 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor for it to be detected | meters | Float | 0.1 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor for it to be detected | meters | Float | 2000 | 0.01 | 2000 |
Distorted |
defines if the image is distorted | Bool | false |
|||
DistortionParameters |
parameters used by distortion* | List of Float | empty list | |||
Fisheye |
defines if the camera has fisheye lens | Bool | false |
|||
Xi |
parameter used by fisheye distortion ** | Float | 0.0 | |||
CubemapSize |
size of the cubemap used by fisheye distortion *** | pixels | Int | 1024 | 512 | 2048 |
* See notes on DistortionParameters
for Color Camera.
** See notes on Xi
for Color Camera.
*** See notes on CubemapSize
for Color Camera.
{
"type": "Depth Camera",
"name": "Depth Camera",
"params": {
"Width": 1920,
"Height": 1080,
"Frequency": 15,
"JpegQuality": 75,
"FieldOfView": 50,
"MinDistance": 0.1,
"MaxDistance": 2000,
"Topic": "/simulator/depth_camera"
},
"transform": {
"x": 0,
"y": 1.7,
"z": -0.2,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Segmentation Camera top#
This sensor returns an image where objects are colored corresponding to their tag:
| Tag | Color | Hex Value |
|---|---|---|
| Car | Blue | #120E97 |
| Road | Purple | #7A3F83 |
| Sidewalk | Orange | #BA8350 |
| Vegetation | Green | #71C02F |
| Obstacle | White | #FFFFFF |
| TrafficLight | Yellow | #FFFF00 |
| Building | Turquoise | #238688 |
| Sign | Dark Yellow | #C0C000 |
| Shoulder | Pink | #FF00FF |
| Pedestrian | Red | #FF0000 |
| Curb | Dark Purple | #4A254F |
If a tag is included in "InstanceSegmentationTags", each instance of objects with that tag is colored differently, but all will have same hue (e.g. all cars will be bluish and all pedestrians will be reddish).
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Width |
defines the width of the image output | pixels | Int | 1920 | 1 | 1920 |
Height |
defines the height of the image output | pixels | Int | 1080 | 1 | 1080 |
Frequency |
defines the maximum rate that messages will be published | Hertz | Int | 15 | 1 | 100 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 60 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor for it to be detected | meters | Float | 0.1 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor for it to be detected | meters | Float | 2000 | 0.01 | 2000 |
Distorted |
defines if the image is distorted | Bool | false |
|||
DistortionParameters |
parameters used by distortion* | List of Float | empty list | |||
Fisheye |
defines if the camera has fisheye lens | Bool | false |
|||
Xi |
parameter used by fisheye distortion ** | Float | 0.0 | |||
CubemapSize |
size of the cubemap used by fisheye distortion *** | pixels | Int | 1024 | 512 | 2048 |
InstanceSegmentationTags |
define tags with instance segmentation | List of String | empty list |
* See notes on DistortionParameters
for Color Camera.
** See notes on Xi
for Color Camera.
*** See notes on CubemapSize
for Color Camera.
{
"type": "Segmentation Camera",
"name": "Segmentation Camera",
"params": {
"Width": 1920,
"Height": 1080,
"Frequency": 15,
"FieldOfView": 50,
"MinDistance": 0.1,
"MaxDistance": 2000,
"InstanceSegmentationTags": [
"Car",
"Pedestrian"
],
"Topic": "/simulator/segmentation_camera"
},
"transform": {
"x": 0,
"y": 1.7,
"z": -0.2,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Lidar top#
This sensor returns a point cloud after 1 revolution.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
VerticalRayAngles |
defines vertical angle for each laser beam* | List of Float | empty list | |||
LaserCount |
defines how many vertically stacked laser beams there are | Int | 32 | 1 | 128 | |
FieldOfView |
defines the vertical angle between bottom and top ray | degrees | Float | 41.33 | 1 | 45 |
CenterAngle |
defines the center of the FieldOfView cone to the horizon (+ means below horizon) | degrees | Float | 10 | -45 | 45 |
MinDistance |
defines how far an object must be from the sensor for it to be detected | meters | Float | 0.5 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor for it to be detected | meters | Float | 100 | 0.01 | 2000 |
RotationFrequency |
defines how fast the sensor rotates | Hertz | Float | 10 | 1 | 30 |
MeasurementsPerRotation |
defines how many measurements each beam takes per rotation | Int | 1500 | 18 | 6000 | |
Compensated |
defines whether or not the point cloud is compensated for the movement of the vehicle | Bool | true |
|||
PointSize |
defines how large of points are visualized | pixels | Float | 2 | 1 | 10 |
PointColor |
defines the color of visualized points | rgba in hex | Color | #FF0000FF |
* If VerticalRayAngles
is not empty, LaserCount
will be automatically set to the length of VerticalRayAngles
, and FieldOfView
and CenterAngle
will be ignored.
A sample of uniformly distributed angles:
{
"type": "Lidar",
"name": "Lidar-Uniform",
"params": {
"LaserCount": 32,
"FieldOfView": 41.33,
"CenterAngle": 10,
"MinDistance": 0.5,
"MaxDistance": 100,
"RotationFrequency": 10,
"MeasurementsPerRotation": 360,
"Compensated": true,
"PointColor": "#ff000000",
"Topic": "/point_cloud",
"Frame": "velodyne"
},
"transform": {
"x": 0,
"y": 2.312,
"z": -0.3679201,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
A sample of non-uniformly distributed angles:
{
"type": "Lidar",
"name": "Lidar-NonUniform",
"params": {
"VerticalRayAngles": [
-25.0, -1.0, -1.667, -15.639,
-11.31, 0.0, -0.667, -8.843,
-7.254, 0.333, -0.333, -6.148,
-5.333, 1.333, 0.667, -4.0,
-4.667, 1.667, 1.0, -3.667,
-3.333, 3.333, 2.333, -2.667,
-3.0, 7.0, 4.667, -2.333,
-2.0, 15.0, 10.333, -1.333
],
"MinDistance": 0.5,
"MaxDistance": 100,
"RotationFrequency": 10,
"MeasurementsPerRotation": 360,
"Compensated": true,
"PointColor": "#ff000000",
"Topic": "/point_cloud",
"Frame": "velodyne"
},
"transform": {
"x": 0,
"y": 2.312,
"z": -0.3679201,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
3D Ground Truth top#
This sensor returns 3D ground truth data for training and creates bounding boxes around the detected objects. The color of the object corresponds to the object's type:
| Object | Color |
|---|---|
| Car | Green |
| Pedestrian | Yellow |
| Bicycle | Cyan |
| Unknown | Magenta |
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 10 | 1 | 100 |
MaxDistance |
defines the how close an object must be to the sensor to be detected | meters | Float | 100 | 1 | 1000 |
{
"type": "3D Ground Truth",
"name": "3D Ground Truth",
"params": {
"Frequency": 10,
"Topic": "/simulator/ground_truth/3d_detections"
},
"transform": {
"x": 0,
"y": 1.975314,
"z": -0.3679201,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
3D Ground Truth Visualizer top#
This sensor will visualize bounding boxes on objects as detected by the AD Stack. It does not publish any data and instead subscribes to a topic from the AD Stack. The color of the boxes are:
| Object | Color |
|---|---|
| Car | Green |
| Pedestrian | Yellow |
| Bicycle | Cyan |
| Unknown | Magenta |
{
"type": "3D Ground Truth Visualizer",
"name": "3D Ground Truth Visualizer",
"params": {
"Topic": "/simulator/ground_truth/3d_visualize"
},
"transform": {
"x": 0,
"y": 1.975314,
"z": -0.3679201,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
CAN-Bus top#
This sensor sends data about the vehicle chassis. The data includes:
- Speed [m/s]
- Throttle [%]
- Braking [%]
- Steering [+/- %]
- Parking Brake Status [bool]
- High Beam Status [bool]
- Low Beam Status [bool]
- Hazard Light Status [bool]
- Fog Light Status [bool]
- Left Turn Signal Status [bool]
- Right Turn Signal Status [bool]
- Wiper Status [bool]
- Reverse Gear Status [bool]
- Selected Gear [Int]
- Engine Status [bool]
- Engine RPM [RPM]
- GPS Latitude [Latitude]
- GPS Longitude [Longitude]
- Altitude [m]
- Orientation [3D Vector of Euler angles]
- Velocity [3D Vector of m/s]
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 10 | 1 | 100 |
{
"type": "CAN-Bus",
"name": "CAN Bus",
"params": {
"Frequency": 10,
"Topic": "/canbus"
},
"transform": {
"x": 0,
"y": 0,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
GPS Device top#
This sensor outputs the GPS location of the vehicle in Longitude/Latitude and Northing/Easting coordintates.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 12.5 | 1 | 100 |
IgnoreMapOrigin |
defines whether or not the actual GPS position is returned. If true , then the Unity world position is returned (as if the MapOrigin were (0,0)) |
Bool | false |
{
"type": "GPS Device",
"name": "GPS",
"params": {
"Frequency": 12.5,
"Topic": "/gps",
"Frame": "gps",
"IgnoreMapOrigin": true
},
"transform": {
"x": 0,
"y": 0,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
GPS Odometry top#
This sensor outputs the GPS location of the vehicle in Longitude/Latitude and Northing/Easting coordintates and the vehicle velocity.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 12.5 | 1 | 100 |
ChildFrame |
used by Autoware | |||||
IgnoreMapOrigin |
defines whether or not the actual GPS position is returned. If true , then the Unity world position is returned (as if the MapOrigin were (0,0)) |
Bool | false |
{
"type": "GPS Odometry",
"name": "GPS Odometry",
"params": {
"Frequency": 12.5,
"Topic": "/gps_odometry",
"Frame": "gps",
"IgnoreMapOrigin": true
},
"transform": {
"x": 0,
"y": 0,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
GPS-INS Status top#
This sensor outputs the status of the GPS correction due to INS. The Simulator is an ideal environment in which GPS is always corrected.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published [Hertz] | Float | 12.5 | 1 | 100 |
{
"type": "GPS-INS Status",
"name": "GPS INS Status",
"params": {
"Frequency": 12.5,
"Topic": "/gps_ins_stat",
"Frame": "gps"
},
"transform": {
"x": 0,
"y": 0,
"z": -1.348649,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Vehicle Control top#
This sensor is required for a vehicle to subscribe to the control topic of an AD Stack.
{
"type": "Vehicle Control",
"name": "AD Car Control",
"params": {
"Topic": "/vehicle_cmd"
}
}
Keyboard Control top#
This sensor is required for a vehicle to accept keyboard control commands. Parameters are not required.
{
"type": "Keyboard Control",
"name": "Keyboard Car Control"
}
Wheel Control top#
This sensor is required for a vehicle to accept Logitech G920 wheel control commands. Parameters are not required.
{
"type": "Wheel Control",
"name": "Wheel Car Control"
}
Manual Control top#
This sensor is required for a vehicle to accept keyboard control commands. Parameters are not required.
{Deprecated}
Will be removed next release. Use Keyboard Control
{
"type": "Manual Control",
"name": "Manual Car Control"
}
Cruise Control top#
This sensor causes the vehicle to accelerate to the desired speed and then maintain the desired speed.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
CruiseSpeed |
defines the desired speed | meters/second | Float | 0 | 0 | 200 |
{
"type": "Cruise Control",
"name": "AD Car Control",
"params": {
"CruiseSpeed": 10
}
}
IMU top#
This sensor output at a fixed rate of 100 Hz. IMU publishes data on topics where the 2nd topic has corrected IMU data.
| Parameter | Description |
|---|---|
CorectedTopic |
defines the 2nd topic that the data is published to |
CorrectedFrame |
defines the 2nd frame for the ROS header |
{
"type": "IMU",
"name": "IMU",
"params": {
"Topic": "/imu",
"Frame": "imu"
},
"transform": {
"x": 0,
"y": 0,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
2D Ground Truth top#
This sensor outputs an image where objects are encased in a box. The color of the box depends on the type of object.
| Object | Color |
|---|---|
| Car | Green |
| Pedestrian | Yellow |
| Bicycle | Cyan |
| Unknown | Magenta |
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 10 | 1 | 100 |
Width |
defines the width of the image | pixels | Int | 1920 | 1 | 1920 |
Height |
defines the height of the iamge | pixels | Int | 1080 | 1 | 1080 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 60 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor to be in the image | meters | Float | 0.1 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor to be in the image | meters | Float | 2000 | 0.01 | 2000 |
DetectionRange |
defines how close an object must be to be given a bounding box | meters | Float | 100 | 0.01 | 2000 |
{
"type": "2D Ground Truth",
"name": "2D Ground Truth",
"params": {
"Frequency": 10,
"Topic": "/simulator/ground_truth/2d_detections"
},
"transform": {
"x": 0,
"y": 1.7,
"z": -0.2,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
2D Ground Truth Visualizer top#
This sensor will visualize bounding boxes on objects as detected by the AD Stack, it does not publish any data. The color of the boxes are:
| Object | Color |
|---|---|
| Car | Green |
| Pedestrian | Yellow |
| Bicycle | Cyan |
| Unknown | Magenta |
In order for bounding boxes to align properly, parameters should match the same camera that the AD Stack is using for detection (i.e. if running Apollo, the parameters should match the sensor named "Main Camera").
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Width |
defines the width of the image | pixels | Int | 1920 | 1 | 1920 |
Height |
defines the height of the iamge | pixels | Int | 1080 | 1 | 1080 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 60 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor to be in the image | meters | Float | 0.1 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor to be in the image | meters | Float | 2000 | 0.01 | 2000 |
{
"type": "2D Ground Truth Visualizer",
"name": "2D Ground Truth Visualizer",
"params": {
"Width": 1920,
"Height": 1080,
"FieldOfView": 50,
"MinDistance": 0.1,
"MaxDistance": 2000,
"Topic": "/simulator/ground_truth/2d_visualize"
},
"transform": {
"x": 0,
"y": 1.7,
"z": -0.2,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Radar top#
This sensor outputs the objects detected by the radar. Detected objects are visualized with a box colored by their type:
| Type | Color |
|---|---|
| Car | Green |
| Agent | Magenta |
| Bicycle | Cyan |
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 13.4 | 1 | 100 |
{
"type": "Radar",
"name": "Radar",
"params": {
"Frequency": 13.4,
"Topic": "/radar"
},
"transform": {
"x": 0,
"y": 0.689,
"z": 2.272,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Ultrasonic top#
This sensor outputs the distance (to the center of the sensor) of the closest point within the sensor's FOV.
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Width |
defines the width of the image output | pixels | Int | 400 | 1 | 1920 |
Height |
defines the height of the image output | pixels | Int | 160 | 1 | 1080 |
Frequency |
defines the maximum rate that messages will be published | Hertz | Int | 15 | 1 | 100 |
JpegQuality |
defines the quality if the image output | % | Int | 75 | 0 | 100 |
FieldOfView |
defines the vertical angle that the camera sees | degrees | Float | 40 | 1 | 90 |
MinDistance |
defines how far an object must be from the sensor for it to be detected | meters | Float | 0.3 | 0.01 | 1000 |
MaxDistance |
defines how close an object must be to the sensor for it to be detected | meters | Float | 2.0 | 0.01 | 2000 |
{
"type": "Ultrasonic",
"name": "Ultrasonic Sensor",
"params": {
"Width": 400,
"Height": 160,
"Frequency": 15,
"JpegQuality": 75,
"FieldOfView": 50,
"MinDistance": 0.3,
"MaxDistance": 2,
"Topic": "/simulator/ultrasonic",
"Frame": "ultrasonic"
},
"transform": {
"x": 0,
"y": 0.5,
"z": 2.5,
"pitch": -13,
"yaw": 0,
"roll": 0
}
}
Control Calibration top#
This sensor outputs control calibration criteria collected by AD Stacks (Apollo, Autoware). It generates steering, throttle or brakes with gear commands between minimum and maximum of velocity during duration.
| Parameter | Description | Unit | Type | Minimum | Maximum |
|---|---|---|---|---|---|
min_velocity |
defines the minimum velocity when criterion is executed | meters/second | Float | 0 | 50.0 |
max_velocity |
defines the maximum velocity when criterion is executed | meters/second | Float | 0 | 50.0 |
throttle |
defines the throttle which makes acceleration | Percent | Float | 0 | 100.0 |
brakes |
defines the brakes which make deceleration | Percent | Float | 0 | 100.0 |
steering |
defines ego vehicle's steering | Percent | Float | -100.0 | 100.0 |
gear |
defines ego vehicle's direction (forward or reverse) | String | |||
duration |
defines criterion's execution time | second | Float | 0 |
{
"type": "Control Calibration",
"name": "Control Calibration",
"params": {
"states": [{
"min_velocity": 0.2,
"max_velocity": 10.0,
"throttle": 23,
"brakes": 0,
"steering": 0,
"gear": "forward",
"duration": 4
},
{
"min_velocity": 0.2,
"max_velocity": 2.0,
"throttle": 22,
"brakes": 0,
"steering": 0,
"gear": "reverse",
"duration": 4
}
]
}
}
Total Control Calibration Criteria:
Transform Sensor top#
This sensor is specifically used to parent other sensors.
For example, if there is a cluster of sensors a Transform
sensor can be added at the location of the cluster
and then the individual sensors can have a transform that is relative to the location of the Transform
sensor`.
Example usage
{
"type": "Transform",
"name": "Cluster Reference",
"transform": {
"x": 0.75,
"y": 1.7,
"z": 1,
"pitch": 0,
"yaw": 0,
"roll": 0
}
},
{
"type": "Color Camera",
"name": "Main Camera",
"params": {
"Width": 1920,
"Height": 1080,
"Frequency": 15,
"JpegQuality": 75,
"FieldOfView": 50,
"MinDistance": 0.1,
"MaxDistance": 2000,
"Topic": "/simulator/main_camera",
"Frame": "camera",
"Distorted": true,
"DistortionParameters": [
-0.25349, 0.11868, 0, 0
]
},
"parent": "Cluster Reference",
"transform": {
"x": 0.1,
"y": 0,
"z": -0.1,
"pitch": 0,
"yaw": 0,
"roll": 0
}
},
{
"type": "Lidar",
"name": "Lidar-Uniform",
"params": {
"LaserCount": 32,
"FieldOfView": 41.33,
"CenterAngle": 10,
"MinDistance": 0.5,
"MaxDistance": 100,
"RotationFrequency": 10,
"MeasurementsPerRotation": 360,
"Compensated": true,
"PointColor": "#ff000000",
"Topic": "/point_cloud",
"Frame": "velodyne"
},
"parent": "Cluster Reference",
"transform": {
"x": 0,
"y": 0.2,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}
Signal Sensor top#
This sensor returns ground truth data for traffic light signals connected to the current lane of ego vehicle and creates bounding boxes around the detected signals. The color of the bounding box corresponds to the signal's type:
| Bounding Box | Signal |
|---|---|
| Green | Green |
| Yellow | Yellow |
| Red | Red |
| Parameter | Description | Unit | Type | Default Value | Minimum | Maximum |
|---|---|---|---|---|---|---|
Frequency |
defines the maximum rate that messages will be published | Hertz | Float | 10 | 1 | 100 |
MaxDistance |
defines how close a traffic light must be to the sensor to be detected | meters | Float | 100 | 1 | 1000 |
{
"type": "Signal",
"name": "Signal Sensor",
"params": {
"Frequency": 10,
"MaxDistance": 100,
"Topic": "/simulator/ground_truth/signals"
},
"transform": {
"x": 0,
"y": 0,
"z": 0,
"pitch": 0,
"yaw": 0,
"roll": 0
}
}


Quick start
CoderStyle is syntax highlighting project for web developper , very easy to include and integrate in your awesome web application .
Last version : v0.1
Languages supported : html , css
Templates available : Monokai , Eiffel , Solarized , Twilight
Install
Very easy to include in your application , just download or clone from github
Using
You will need to include the template cs-monokai.min.css
and the scriptcoderstyle.min.js
files you downloaded or by cdn in your layout or pages.
Creators
Marwen Hlaoui
Copyright and license
CoderStyle is free project distributed under the terms of the MIT license.


2. Nosetests¶
We use nosetests and not __main__
to test all functionality so they can me
automatically run and reports can be generated. A project that does not have a
sufficient number of tests to make sure the module works can not be accepted.
To use them you need to install nose with
$ pip install nose
All nose tests are included in the folder tests
.
A simple example is
Note that all tests have specific function names of the form
def test_number_topic (self)
the number is defined to order them and is typically something like 001
, note
the leading spaces. the topic is a descriptive term on what we test.
in def setup(self)
we declare a setup that is run prior to each test being
executed.
an assert simply returns tru or false through a condition that is checked to see if the test succeds or fails.
Note that all nosetest functions start with a HEADING()
which conveniently
prints a banner with the function name and thus helps in debugging in case of
errors.
Invocation is simply done with the comment lines you see on top that you will include.
in our case the test is called test_key.py
so we include on the top
#############################################
# nosetest -v --nopature
# nosetests -v --nocapture tests/test_key.py
#############################################
you can than execute the test with either command. More information is printed with the command
$ nosetests -v --nocapture tests/test_key.py


{{.basics.first}} {{.basics.last}}
{{.basics.location.address}}
{{.basics.location.city}} {{.basics.location.postalcode}}
{{.basics.location.region}}, {{.basics.location.country}}
Interests
{{range .interests}}{{if .name}}
{{.name}}
{{end}}- {{range .keywords}}
- {{ . }} {{end}}
Languages
- {{range .languages}}
- {{ .language }}: {{.fluency}} {{end}}
Skills
Click on a node to open/collapse...
Want to know more?
There is a dedicated section for my publications. You can also just shoot me a mail.


This is an example of an HTML5 form where the form fields show the validity state as the user types in each field. Back to User Agent Man HTML5 Forms article
Form fields labelled are mandatory.


|
Binding of Isaac - Afterbirth+ Lua Reference/Guide
|
Public Member Functions | |
| RenderGlow (Vector position) | |
| RenderBody (Vector position) | |
| RenderHead (Vector position) | |
| RenderTop (Vector position) | |
| string | GetName () |
| AddMaxHearts (integer MaxHearts, boolean IgnoreKeeper) | |
| boolean | HasFullHearts () |
| boolean | HasFullHeartsAndSoulHearts () |
| AddHearts (integer Hearts) | |
| AddEternalHearts (integer EternalHearts) | |
| AddSoulHearts (integer SoulHearts) | |
| AddBlackHearts (integer BlackHearts) | |
| RemoveBlackHeart (integer BlackHeart) | |
| boolean | IsBlackHeart (integer Heart) |
| AddJarHearts (integer Hearts) | |
| integer | GetJarHearts () |
| AddJarFlies (integer Flies) | |
| integer | GetJarFlies () |
| AddCoins (integer Amount) | |
| AddBombs (integer Amount) | |
| AddKeys (integer Amount) | |
| AddGoldenKey () | |
| RemoveGoldenKey () | |
| AddGoldenBomb () | |
| RemoveGoldenBomb () | |
| AddGoldenHearts (integer Hearts) | |
| Entity & | AddBlueSpider (Vector Position) |
| RemoveBlueSpider () | |
| Entity & | AddBlueFlies (integer Amount, Vector Position, Entity Target) |
| RemoveBlueFly () | |
| AddPrettyFly () | |
| boolean | TryUseKey () |
| AddCostume (Config::Item Item, boolean ItemStateOnly) | |
| AddNullCostume (Config::NullItemID NullId) | |
| for Lua More... | |
| RemoveCostume (Config::Item Item) | |
| RemoveSkinCostume () | |
| ClearCostumes () | |
| QueueItem (Config::Item Item, integer Charge, boolean Touched) | |
| Add Collectible/Trinket after animation is finished. More... | |
| boolean | FlushQueueItem () |
| called after animation is finished, or on special occasions to prevent bugs More... | |
| boolean | IsItemQueueEmpty () |
| AddCollectible (CollectibleType Type, integer Charge, boolean AddConsumables) | |
| integer | GetCollectibleCount () |
| AddTrinket (TrinketType Type) | |
| s32 GetCollectibleNum( eCollectibleType Collectible ) const; More... | |
| boolean | TryRemoveTrinket (TrinketType Type) |
| DropTrinket (Vector DropPos, boolean ReplaceTick) | |
| integer | GetMaxTrinkets () |
| integer | GetMaxPoketItems () |
| DropPoketItem (integer PocketNum, Vector Pos) | |
| RemoveCollectible (CollectibleType Type) | |
| ClearTemporaryEffects () | |
| Will be called when player exits the room. More... | |
| DonateLuck (integer Luck) | |
| boolean | CanPickBlackHearts () |
| returns true if player has room for more black hearts More... | |
| boolean | CanPickGoldenHearts () |
| returns true if player has room for more golden hearts More... | |
| CollectibleType | GetActiveItem () |
| TODO: Replace those calls with new class/structure that contains all item information. More... | |
| integer | GetActiveCharge () |
| integer | GetBatteryCharge () |
| integer | GetActiveSubCharge () |
| SetActiveCharge (integer Charge) | |
| DischargeActiveItem () | |
| boolean | NeedsCharge () |
| boolean | FullCharge () |
| return true if the item was fully charged, false otherwise. If player has battery it will first try to fill first charge slot, then the battery slot. More... | |
| const PlayerPocketItem & | GetPocketItem (integer SlotId) |
| AddCard (Card Card) | |
| AddPill (PillColor Pill) | |
| Card | GetCard (integer SlotId) |
| PillColor | GetPill (integer SlotId) |
| SetCard (integer SlotId, Card Card) | |
| SetPill (integer SlotId, PillColor Pill) | |
| boolean | HasCollectible (CollectibleType Type) |
| integer | GetCollectibleNum (CollectibleType Type) |
| boolean | HasTrinket (TrinketType Type) |
| boolean | HasPlayerForm (PlayerForm Form) |
| boolean | CanAddCollectible () |
| boolean | TryHoldTrinket (TrinketType Type) |
| SetFullHearts () | |
| AddCacheFlags (integer Flags) | |
| Reevaluate Damage, Firerate, Shot speed. More... | |
| EvaluateItems () | |
| RespawnFamiliars () | |
| Entity & | GetNPCTarget () |
| Direction | GetMovementDirection () |
| Direction | GetFireDirection () |
| Direction | GetHeadDirection () |
| const Vector & | GetAimDirection () |
| const Vector & | GetMovementVector () |
| const Vector & | GetRecentMovementVector () |
| Returns the joystick direction that drives player movement, taking into account certain modifiers like disabled controls and seed effects. More... | |
| Vector | GetMovementJoystick () |
| Vector | GetShootingJoystick () |
| boolean | AreOpposingShootDirectionsPressed () |
| Returns the non-zero joystick direction from the most recent movement input, but goes to zero after the player comes to a stop. More... | |
| const Vector & | GetLastDirection () |
| const Vector & | GetVelocityBeforeUpdate () |
| float | GetSmoothBodyRotation () |
| float | GetTearPoisonDamage () |
| integer | GetBombFlags () |
| EntityBomb::BombVariant | GetBombVariant (integer TearFlags, boolean ForceSmallBomb) |
| Pass tear flags to add extra effects to the bomb visual like burn -> hot bombs, even if player doesn't have Hot Bombs collectible. ForceSmallBomb will override large bomb variants for TEAR_PERSISTENT. More... | |
| TearParams | GetTearHitParams (WeaponType WeaponType, float DamageScale, integer TearDisplacement) |
| integer | GetHearts () |
| integer | GetMaxHearts () |
| integer | GetSoulHearts () |
| integer | GetBlackHearts () |
| integer | GetEternalHearts () |
| This does not return the # of black hearts, this returns the bit mask for which soul hearts are black hearts. More... | |
| integer | GetExtraLives () |
| integer | GetNumBombs () |
| integer | GetNumKeys () |
| boolean | HasGoldenKey () |
| boolean | HasGoldenBomb () |
| integer | GetGoldenHearts () |
| integer | GetNumCoins () |
| PlayerType | GetPlayerType () |
| TrinketType | GetTrinket (integer TrinketIndex) |
| integer | GetNumBlueFlies () |
| integer | GetNumBlueSpiders () |
| CollectibleType | GetItemState () |
| UseActiveItem (CollectibleType Item, boolean ShowAnim, boolean KeepActiveItem, boolean AllowNonMainPlayer, boolean ToAddCostume) | |
| integer | GetTearRangeModifier () |
| integer | GetTrinketMultiplier () |
| TemporaryEffects & | GetEffects () |
| boolean | HasWeaponType (WeaponType WeaponType) |
| Entity & | GetActiveWeaponEntity () |
| Entity & | GetTractorBeam () |
| boolean | CanPickupItem () |
| Can Player pick up an item right now? More... | |
| boolean | IsHoldingItem () |
| Is Player holding up an item (card/collectible/etc) More... | |
| boolean | IsHeldItemVisible () |
| Revive () | |
| revive player More... | |
| TryRemoveCollectibleCostume (CollectibleType Collectible, boolean KeepPersistent) | |
| tries to remove a costume based on some filters More... | |
| TryRemoveTrinketCostume (TrinketType Trinket) | |
| tries to remove a costume based on some filters More... | |
| TryRemoveNullCostume (Config::NullItemID NullId) | |
| AnimateCollectible (CollectibleType Collectible, string AnimName, string SpriteAnimName) | |
| AnimateTrinket (TrinketType Trinket, string AnimName, string SpriteAnimName) | |
| AnimateCard (Card Card, string AnimName) | |
| AnimatePill (PillColor Pill, string AnimName) | |
| AnimateTrapdoor () | |
| end of a stage More... | |
| AnimateLightTravel () | |
| end of a stage More... | |
| AnimateAppear () | |
| beginning of a stage More... | |
| AnimateTeleport (boolean Up) | |
| teleport to another room More... | |
| AnimateHappy () | |
| thumbs up More... | |
| AnimateSad () | |
| oh no! More... | |
| AnimatePitfallIn () | |
| Fall into pitfall. More... | |
| AnimatePitfallOut () | |
| Jump out of pitfall. More... | |
| boolean | IsExtraAnimationFinished () |
| StopExtraAnimation () | |
| AddControlsCooldown (integer Cooldown) | |
| PlayExtraAnimation (string Animation) | |
| QueueExtraAnimation (string Animation) | |
| integer | GetDamageCooldown () |
| ResetDamageCooldown () | |
| SetMinDamageCooldown (integer DamageCooldown) | |
| boolean | AreControlsEnabled () |
| UseCard (Card Card) | |
| UsePill (PillEffect PillEffect, PillColor PillColor) | |
| boolean | HasInvincibility () |
| returns true when player is in an invincibility state More... | |
| SetShootingCooldown (integer Cooldown) | |
| SetTargetTrapDoor (GridEntity TrapDoor) | |
| EntityLaser & | FireDelayedBrimstone (float Angle, Entity Parent) |
| const EntityRef & | GetLastDamageSource () |
| integer | GetLastDamageFlags () |
| integer | GetTotalDamageTaken () |
| EntityTear & | FireTear (Vector Position, Vector Velocity, boolean CanBeEye, boolean NoTractorBeam, boolean CanTriggerStreakEnd) |
| EntityBomb & | FireBomb (Vector Position, Vector Velocity) |
| EntityLaser & | FireBrimstone (Vector Direction) |
| EntityLaser & | FireTechLaser (Vector Position, LaserOffset OffsetID, Vector Direction, boolean LeftEye, boolean OneHit) |
| EntityLaser & | FireTechXLaser (Vector Position, Vector Direction, float Radius) |
| EntityKnife & | FireKnife (Entity Parent, float RotationOffset, boolean CantOverwrite, integer SubType) |
| BabySubType | GetBabySkin () |
| boolean | CanShoot () |
| boolean | IsP2Appearing () |
| boolean | IsFullSpriteRendering () |
| RNG & | GetCollectibleRNG (CollectibleType ID) |
| RNG & | GetTrinketRNG (TrinketType ID) |
| RNG & | GetPillRNG (PillEffect ID) |
| RNG & | GetCardRNG (Card ID) |
| AddDeadEyeCharge () | |
| ClearDeadEyeCharge () | |
| CollectibleType | GetZodiacEffect () |
| boolean | IsPosInSpotLight (Vector Position) |
| MultiShotParams | GetMultiShotParams () |
| PosVel | GetMultiShotPositionVelocity (integer LoopIndex, WeaponType Weapon, Vector ShotDirection, float ShotSpeed, MultiShotParams params) |
| Call this function in a loop with values from 0 to MultiShotParams.NumProjectiles-1 (inclusive) More... | |
| Vector | GetFlyingOffset () |
| boolean | WillPlayerRevive () |
| integer | GetLastActionTriggers () |
| float | GetGreedDonationBreakChance () |
| Vector | GetMovementInput () |
| Vector | GetShootingInput () |
| boolean | HasTimedItem () |
| Kept for avoiding modding issues. More... | |
| InitBabySkin () | |
| boolean | CanTurnHead () |
| returns true if head should react to keys or false otherwise More... | |
| CheckFamiliar (integer FamiliarVariant, integer TargetCount, RNG rng) | |
| UpdateCanShoot () | |
| Vector | GetLaserOffset (LaserOffset ID, Vector Direction) |
| Vector | GetTearMovementInheritance (Vector ShotDirection) |
| Vector | GetCostumeNullPos (string NullFrameName, boolean HeadScale, Vector Direction) |
| ReplaceCostumeSprite (Config::Item Item, string SpritePath, integer SpriteId) | |
| AddPlayerFormCostume (PlayerForm Form) | |
| ResetItemState () | |
| Made this public so Room transtiions can call this to prevent lock ups. More... | |
| EntityLaser & | SpawnMawOfVoid (integer Timeout) |
| AddDollarBillEffect () | |
| ShootRedCandle (Vector Direction) | |
| for ghost pepper item + poop and farts More... | |
| DoZitEffect (Vector Direction) | |
| SwapActiveItems () | |
| Public Member Functions inherited from Entity | |
| table | GetData () |
| Update () | |
| Render (Vector Offset) | |
| boolean | RenderShadowLayer (Vector Offset) |
| PostRender () | |
| boolean | TakeDamage (float Damage, integer Flags, EntityRef Source, integer DamageCountdown) |
| boolean | HasMortalDamage () |
| Kill () | |
| Kills the entity and makes a blood splat or gibs. More... | |
| Die () | |
| Remove () | |
| BloodExplode () | |
| Explodes with gibs and blood. More... | |
| AddVelocity (Vector Velocity) | |
| MultiplyFriction (float Value) | |
| SetColor (KColor KColor, integer Duration, integer Priority, boolean Fadeout, boolean Share) | |
| const KColor & | GetColor () |
| SetSpriteFrame (string AnimationName, integer FrameNum) | |
| SetSpriteOverlayFrame (string AnimationName, integer FrameNum) | |
| SetSize (float Size, Vector SizeMulti, integer NumGridCollisionPoints) | |
| boolean | CollidesWithGrid () |
| boolean | IsEnemy () |
| return true for NPCs that are not controlled by the player More... | |
| boolean | IsActiveEnemy (boolean includeDead) |
| return true for non background NPCs (ex: every enemy except fire and shopkeepers) More... | |
| boolean | IsVulnerableEnemy () |
| return true for enemies that can be damaged More... | |
| boolean | IsFlying () |
| AddEntityFlags (integer Flags) | |
| ClearEntityFlags (integer Flags) | |
| integer | GetEntityFlags () |
| boolean | HasEntityFlags (integer Flags) |
| boolean | HasFullHealth () |
| AddHealth (float HitPoints) | |
| AddPoison (EntityRef Source, integer Duration, float Damage) | |
| AddFreeze (EntityRef Source, integer Duration) | |
| AddSlowing (EntityRef Source, integer Duration, float SlowValue, KColor SlowColor) | |
| Makes the friction higher. More... | |
| AddCharmed (integer Duration) | |
| AddConfusion (EntityRef Source, integer Duration, boolean IgnoreBosses) | |
| AddMidasFreeze (EntityRef Source, integer Duration) | |
| AddFear (EntityRef Source, integer Duration) | |
| AddBurn (EntityRef Source, integer Duration, float Damage) | |
| AddShrink (EntityRef Source, integer Duration) | |
| RemoveStatusEffects () | |
| boolean | Exists () |
| boolean | IsDead () |
| boolean | IsVisible () |
| boolean | IsInvincible () |
| boolean | CanShutDoors () |
| enemies keep the doors shut More... | |
| boolean | IsBoss () |
| bosses display health bar More... | |
| BossId | GetBossID () |
| Entity & | GetLastParent () |
| Entity & | GetLastChild () |
| boolean | HasCommonParentWithEntity (Entity Other) |
| boolean | IsFrame (integer Frame, integer Offset) |
| true every X frames More... | |
| RNG & | GetDropRNG () |
| Sprite & | GetSprite () |
| EntityPlayer | ToPlayer () |
| EntityEffect | ToEffect () |
| EntityNPC | ToNPC () |
| EntityPickup | ToPickup () |
| EntityFamiliar | ToFamiliar () |
| EntityBomb | ToBomb () |
| EntityKnife | ToKnife () |
| EntityLaser | ToLaser () |
| EntityTear | ToTear () |
| EntityProjectile | ToProjectile () |
Public Attributes | |
| const Vector & | TearsOffset |
| boolean | ControlsEnabled |
| integer | ControlsCooldown |
| const EntityDesc & | FriendBallEnemy |
| Vector | SpriteScale |
| const integer | ControllerIndex |
| s32 GetItemStateCooldown( void ) const { return m_ItemStateCooldown; } More... | |
| integer | FireDelay |
| How long until the player can spawn their next tear? More... | |
| integer | MaxFireDelay |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How long between each tear can spawn? More... | |
| float | ShotSpeed |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast does the tear travel when spawned? More... | |
| float | Damage |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How much damage do the players tears or other main weapons do? More... | |
| float | TearHeight |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How high above the ground is the tear when it spawns? Affects range. More... | |
| float | TearFallingSpeed |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast is the tear moving up or down when it spawns? Affects range. More... | |
| float | TearFallingAcceleration |
| float | MoveSpeed |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast can the player move? More... | |
| integer | TearFlags |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How much gravity does the tear have to start? Affects range. More... | |
| KColor | TearColor |
| KColor | LaserColor |
| boolean | CanFly |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. Can the player fly over rocks and pits? More... | |
| float | Luck |
| Player stat - Only change this in a callback to MC_EVALUATE_CACHE. Better luck generally means better random events. More... | |
| BabySubType | BabySkin |
| QueueItemData | QueuedItem |
| integer | ItemHoldCooldown |
| Used for avoiding player get stucked between rocks when switching a flying item with other active item. More... | |
| ActiveItemDesc | SecondaryActiveItem |
| Public Attributes inherited from Entity | |
| float | Friction |
| loaded from entity config More... | |
| Vector | Position |
| Vector | Velocity |
| const EntityType | Type |
| integer | Variant |
| void SetType(eEntityType Type); More... | |
| integer | SubType |
| EntityType | SpawnerType |
| integer | SpawnerVariant |
| const KColor & | SplatColor |
| boolean | Visible |
| const Vector & | PositionOffset |
| integer | RenderZOffset |
| boolean | FlipX |
| const Vector & | SpriteOffset |
| const Vector & | SpriteScale |
| float | SpriteRotation |
| Vector | SizeMulti |
| float | Mass |
| float | MaxHitPoints |
| float | HitPoints |
| const integer | Index |
| const Vector & | TargetPosition |
| GridCollisionClass | GridCollisionClass |
| EntityCollisionClass | EntityCollisionClass |
| float | CollisionDamage |
| const integer | SpawnGridIndex |
| Entity & | Parent |
| Entity & | Child |
| Entity & | Target |
| Entity & | SpawnerEntity |
| const integer | FrameCount |
| const integer | InitSeed |
| const integer | DropSeed |
| float | DepthOffset |
| EntityPlayer::AddBlackHearts | ( | integer | BlackHearts | ) |
| EntityPlayer::AddBombs | ( | integer | Amount | ) |
| EntityPlayer::AddCacheFlags | ( | integer | Flags | ) |
Reevaluate Damage, Firerate, Shot speed.
| EntityPlayer::AddCard | ( | Card | Card | ) |
| EntityPlayer::AddCoins | ( | integer | Amount | ) |
| EntityPlayer::AddCollectible | ( | CollectibleType | Type, |
| integer | Charge, | ||
| boolean | AddConsumables | ||
| ) |
| EntityPlayer::AddControlsCooldown | ( | integer | Cooldown | ) |
| EntityPlayer::AddCostume | ( | Config::Item | Item, |
| boolean | ItemStateOnly | ||
| ) |
| EntityPlayer::AddDeadEyeCharge | ( | ) |
| EntityPlayer::AddDollarBillEffect | ( | ) |
| EntityPlayer::AddEternalHearts | ( | integer | EternalHearts | ) |
| EntityPlayer::AddGoldenBomb | ( | ) |
| EntityPlayer::AddGoldenHearts | ( | integer | Hearts | ) |
| EntityPlayer::AddGoldenKey | ( | ) |
| EntityPlayer::AddHearts | ( | integer | Hearts | ) |
| EntityPlayer::AddJarFlies | ( | integer | Flies | ) |
| EntityPlayer::AddJarHearts | ( | integer | Hearts | ) |
| EntityPlayer::AddKeys | ( | integer | Amount | ) |
| EntityPlayer::AddMaxHearts | ( | integer | MaxHearts, |
| boolean | IgnoreKeeper | ||
| ) |
| EntityPlayer::AddNullCostume | ( | Config::NullItemID | NullId | ) |
for Lua
| EntityPlayer::AddPill | ( | PillColor | Pill | ) |
| EntityPlayer::AddPlayerFormCostume | ( | PlayerForm | Form | ) |
| EntityPlayer::AddPrettyFly | ( | ) |
| EntityPlayer::AddSoulHearts | ( | integer | SoulHearts | ) |
| EntityPlayer::AddTrinket | ( | TrinketType | Type | ) |
s32 GetCollectibleNum( eCollectibleType Collectible ) const;
| EntityPlayer::AnimateAppear | ( | ) |
beginning of a stage
| EntityPlayer::AnimateCard | ( | Card | Card, |
| string | AnimName | ||
| ) |
| EntityPlayer::AnimateCollectible | ( | CollectibleType | Collectible, |
| string | AnimName, | ||
| string | SpriteAnimName | ||
| ) |
| EntityPlayer::AnimateHappy | ( | ) |
thumbs up
| EntityPlayer::AnimateLightTravel | ( | ) |
end of a stage
| EntityPlayer::AnimatePill | ( | PillColor | Pill, |
| string | AnimName | ||
| ) |
| EntityPlayer::AnimatePitfallIn | ( | ) |
Fall into pitfall.
| EntityPlayer::AnimatePitfallOut | ( | ) |
Jump out of pitfall.
| EntityPlayer::AnimateSad | ( | ) |
oh no!
| EntityPlayer::AnimateTeleport | ( | boolean | Up | ) |
teleport to another room
| EntityPlayer::AnimateTrapdoor | ( | ) |
end of a stage
| EntityPlayer::AnimateTrinket | ( | TrinketType | Trinket, |
| string | AnimName, | ||
| string | SpriteAnimName | ||
| ) |
| boolean EntityPlayer::AreControlsEnabled | ( | ) |
| boolean EntityPlayer::AreOpposingShootDirectionsPressed | ( | ) |
Returns the non-zero joystick direction from the most recent movement input, but goes to zero after the player comes to a stop.
| boolean EntityPlayer::CanAddCollectible | ( | ) |
| boolean EntityPlayer::CanPickBlackHearts | ( | ) |
returns true if player has room for more black hearts
| boolean EntityPlayer::CanPickGoldenHearts | ( | ) |
returns true if player has room for more golden hearts
| boolean EntityPlayer::CanPickupItem | ( | ) |
Can Player pick up an item right now?
| boolean EntityPlayer::CanShoot | ( | ) |
| boolean EntityPlayer::CanTurnHead | ( | ) |
returns true if head should react to keys or false otherwise
| EntityPlayer::CheckFamiliar | ( | integer | FamiliarVariant, |
| integer | TargetCount, | ||
| RNG | rng | ||
| ) |
| EntityPlayer::ClearCostumes | ( | ) |
| EntityPlayer::ClearDeadEyeCharge | ( | ) |
| EntityPlayer::ClearTemporaryEffects | ( | ) |
Will be called when player exits the room.
| EntityPlayer::DischargeActiveItem | ( | ) |
| EntityPlayer::DonateLuck | ( | integer | Luck | ) |
| EntityPlayer::DoZitEffect | ( | Vector | Direction | ) |
| EntityPlayer::DropPoketItem | ( | integer | PocketNum, |
| Vector | Pos | ||
| ) |
| EntityPlayer::DropTrinket | ( | Vector | DropPos, |
| boolean | ReplaceTick | ||
| ) |
| EntityPlayer::EvaluateItems | ( | ) |
| EntityBomb& EntityPlayer::FireBomb | ( | Vector | Position, |
| Vector | Velocity | ||
| ) |
| EntityLaser& EntityPlayer::FireBrimstone | ( | Vector | Direction | ) |
| EntityLaser& EntityPlayer::FireDelayedBrimstone | ( | float | Angle, |
| Entity | Parent | ||
| ) |
| EntityKnife& EntityPlayer::FireKnife | ( | Entity | Parent, |
| float | RotationOffset, | ||
| boolean | CantOverwrite, | ||
| integer | SubType | ||
| ) |
| EntityTear& EntityPlayer::FireTear | ( | Vector | Position, |
| Vector | Velocity, | ||
| boolean | CanBeEye, | ||
| boolean | NoTractorBeam, | ||
| boolean | CanTriggerStreakEnd | ||
| ) |
This replaces the protected fire_tear() to allow other entities (Such as bombs) to easily shoot tears in the same manner and with all the effects the player does. (Ex. Sad Bombs)
| EntityLaser& EntityPlayer::FireTechLaser | ( | Vector | Position, |
| LaserOffset | OffsetID, | ||
| Vector | Direction, | ||
| boolean | LeftEye, | ||
| boolean | OneHit | ||
| ) |
| EntityLaser& EntityPlayer::FireTechXLaser | ( | Vector | Position, |
| Vector | Direction, | ||
| float | Radius | ||
| ) |
| boolean EntityPlayer::FlushQueueItem | ( | ) |
called after animation is finished, or on special occasions to prevent bugs
| boolean EntityPlayer::FullCharge | ( | ) |
return true if the item was fully charged, false otherwise. If player has battery it will first try to fill first charge slot, then the battery slot.
| integer EntityPlayer::GetActiveCharge | ( | ) |
| CollectibleType EntityPlayer::GetActiveItem | ( | ) |
TODO: Replace those calls with new class/structure that contains all item information.
| integer EntityPlayer::GetActiveSubCharge | ( | ) |
| Entity& EntityPlayer::GetActiveWeaponEntity | ( | ) |
| const Vector& EntityPlayer::GetAimDirection | ( | ) |
| BabySubType EntityPlayer::GetBabySkin | ( | ) |
| integer EntityPlayer::GetBatteryCharge | ( | ) |
| integer EntityPlayer::GetBlackHearts | ( | ) |
| integer EntityPlayer::GetBombFlags | ( | ) |
| EntityBomb::BombVariant EntityPlayer::GetBombVariant | ( | integer | TearFlags, |
| boolean | ForceSmallBomb | ||
| ) |
Pass tear flags to add extra effects to the bomb visual like burn -> hot bombs, even if player doesn't have Hot Bombs collectible. ForceSmallBomb will override large bomb variants for TEAR_PERSISTENT.
| Card EntityPlayer::GetCard | ( | integer | SlotId | ) |
| integer EntityPlayer::GetCollectibleCount | ( | ) |
| integer EntityPlayer::GetCollectibleNum | ( | CollectibleType | Type | ) |
| RNG& EntityPlayer::GetCollectibleRNG | ( | CollectibleType | ID | ) |
| Vector EntityPlayer::GetCostumeNullPos | ( | string | NullFrameName, |
| boolean | HeadScale, | ||
| Vector | Direction | ||
| ) |
| integer EntityPlayer::GetDamageCooldown | ( | ) |
| TemporaryEffects& EntityPlayer::GetEffects | ( | ) |
| integer EntityPlayer::GetEternalHearts | ( | ) |
This does not return the # of black hearts, this returns the bit mask for which soul hearts are black hearts.
| integer EntityPlayer::GetExtraLives | ( | ) |
| Direction EntityPlayer::GetFireDirection | ( | ) |
| Vector EntityPlayer::GetFlyingOffset | ( | ) |
| integer EntityPlayer::GetGoldenHearts | ( | ) |
| float EntityPlayer::GetGreedDonationBreakChance | ( | ) |
| Direction EntityPlayer::GetHeadDirection | ( | ) |
| integer EntityPlayer::GetHearts | ( | ) |
| CollectibleType EntityPlayer::GetItemState | ( | ) |
| integer EntityPlayer::GetJarFlies | ( | ) |
| integer EntityPlayer::GetJarHearts | ( | ) |
| Vector EntityPlayer::GetLaserOffset | ( | LaserOffset | ID, |
| Vector | Direction | ||
| ) |
| integer EntityPlayer::GetLastActionTriggers | ( | ) |
| integer EntityPlayer::GetLastDamageFlags | ( | ) |
| const EntityRef& EntityPlayer::GetLastDamageSource | ( | ) |
| const Vector& EntityPlayer::GetLastDirection | ( | ) |
| integer EntityPlayer::GetMaxHearts | ( | ) |
| integer EntityPlayer::GetMaxPoketItems | ( | ) |
| integer EntityPlayer::GetMaxTrinkets | ( | ) |
| Direction EntityPlayer::GetMovementDirection | ( | ) |
| Vector EntityPlayer::GetMovementInput | ( | ) |
| Vector EntityPlayer::GetMovementJoystick | ( | ) |
| const Vector& EntityPlayer::GetMovementVector | ( | ) |
| MultiShotParams EntityPlayer::GetMultiShotParams | ( | ) |
| PosVel EntityPlayer::GetMultiShotPositionVelocity | ( | integer | LoopIndex, |
| WeaponType | Weapon, | ||
| Vector | ShotDirection, | ||
| float | ShotSpeed, | ||
| MultiShotParams | params | ||
| ) |
Call this function in a loop with values from 0 to MultiShotParams.NumProjectiles-1 (inclusive)
| string EntityPlayer::GetName | ( | ) |
| Entity& EntityPlayer::GetNPCTarget | ( | ) |
normally returns the player itself can redirect enemy attacks to a different entity such as Best Friend
| integer EntityPlayer::GetNumBlueFlies | ( | ) |
| integer EntityPlayer::GetNumBlueSpiders | ( | ) |
| integer EntityPlayer::GetNumBombs | ( | ) |
| integer EntityPlayer::GetNumCoins | ( | ) |
| integer EntityPlayer::GetNumKeys | ( | ) |
| PillColor EntityPlayer::GetPill | ( | integer | SlotId | ) |
| RNG& EntityPlayer::GetPillRNG | ( | PillEffect | ID | ) |
| PlayerType EntityPlayer::GetPlayerType | ( | ) |
| const PlayerPocketItem& EntityPlayer::GetPocketItem | ( | integer | SlotId | ) |
| const Vector& EntityPlayer::GetRecentMovementVector | ( | ) |
Returns the joystick direction that drives player movement, taking into account certain modifiers like disabled controls and seed effects.
| Vector EntityPlayer::GetShootingInput | ( | ) |
| Vector EntityPlayer::GetShootingJoystick | ( | ) |
| float EntityPlayer::GetSmoothBodyRotation | ( | ) |
| integer EntityPlayer::GetSoulHearts | ( | ) |
| TearParams EntityPlayer::GetTearHitParams | ( | WeaponType | WeaponType, |
| float | DamageScale, | ||
| integer | TearDisplacement | ||
| ) |
For Lua s32 GetBombVariant( u32 UpperBits, u32 LowerBits) const { return GetBombVariant( (uint64_t)UpperBits << 32 | LowerBits, false ); } ; Used for tear parameters that are calculated on hit (ex: Tough love, Common cold), DamageScale is used for scale calculation based on damage
| float EntityPlayer::GetTearPoisonDamage | ( | ) |
| integer EntityPlayer::GetTearRangeModifier | ( | ) |
| integer EntityPlayer::GetTotalDamageTaken | ( | ) |
| Entity& EntityPlayer::GetTractorBeam | ( | ) |
| TrinketType EntityPlayer::GetTrinket | ( | integer | TrinketIndex | ) |
| integer EntityPlayer::GetTrinketMultiplier | ( | ) |
| RNG& EntityPlayer::GetTrinketRNG | ( | TrinketType | ID | ) |
| const Vector& EntityPlayer::GetVelocityBeforeUpdate | ( | ) |
| CollectibleType EntityPlayer::GetZodiacEffect | ( | ) |
| boolean EntityPlayer::HasCollectible | ( | CollectibleType | Type | ) |
| boolean EntityPlayer::HasFullHearts | ( | ) |
| boolean EntityPlayer::HasFullHeartsAndSoulHearts | ( | ) |
| boolean EntityPlayer::HasGoldenBomb | ( | ) |
| boolean EntityPlayer::HasGoldenKey | ( | ) |
| boolean EntityPlayer::HasInvincibility | ( | ) |
returns true when player is in an invincibility state
| boolean EntityPlayer::HasPlayerForm | ( | PlayerForm | Form | ) |
| boolean EntityPlayer::HasTimedItem | ( | ) |
Kept for avoiding modding issues.
| boolean EntityPlayer::HasTrinket | ( | TrinketType | Type | ) |
| boolean EntityPlayer::HasWeaponType | ( | WeaponType | WeaponType | ) |
| EntityPlayer::InitBabySkin | ( | ) |
| boolean EntityPlayer::IsBlackHeart | ( | integer | Heart | ) |
| boolean EntityPlayer::IsExtraAnimationFinished | ( | ) |
| boolean EntityPlayer::IsFullSpriteRendering | ( | ) |
| boolean EntityPlayer::IsHeldItemVisible | ( | ) |
| boolean EntityPlayer::IsHoldingItem | ( | ) |
Is Player holding up an item (card/collectible/etc)
| boolean EntityPlayer::IsItemQueueEmpty | ( | ) |
| boolean EntityPlayer::IsP2Appearing | ( | ) |
| boolean EntityPlayer::IsPosInSpotLight | ( | Vector | Position | ) |
| boolean EntityPlayer::NeedsCharge | ( | ) |
| EntityPlayer::PlayExtraAnimation | ( | string | Animation | ) |
| EntityPlayer::QueueExtraAnimation | ( | string | Animation | ) |
| EntityPlayer::QueueItem | ( | Config::Item | Item, |
| integer | Charge, | ||
| boolean | Touched | ||
| ) |
Add Collectible/Trinket after animation is finished.
| EntityPlayer::RemoveBlackHeart | ( | integer | BlackHeart | ) |
| EntityPlayer::RemoveBlueFly | ( | ) |
| EntityPlayer::RemoveBlueSpider | ( | ) |
| EntityPlayer::RemoveCollectible | ( | CollectibleType | Type | ) |
| EntityPlayer::RemoveCostume | ( | Config::Item | Item | ) |
| EntityPlayer::RemoveGoldenBomb | ( | ) |
| EntityPlayer::RemoveGoldenKey | ( | ) |
| EntityPlayer::RemoveSkinCostume | ( | ) |
| EntityPlayer::RenderBody | ( | Vector | position | ) |
| EntityPlayer::RenderGlow | ( | Vector | position | ) |
| EntityPlayer::RenderHead | ( | Vector | position | ) |
| EntityPlayer::RenderTop | ( | Vector | position | ) |
| EntityPlayer::ReplaceCostumeSprite | ( | Config::Item | Item, |
| string | SpritePath, | ||
| integer | SpriteId | ||
| ) |
| EntityPlayer::ResetDamageCooldown | ( | ) |
| EntityPlayer::ResetItemState | ( | ) |
Made this public so Room transtiions can call this to prevent lock ups.
| EntityPlayer::RespawnFamiliars | ( | ) |
| EntityPlayer::Revive | ( | ) |
revive player
| EntityPlayer::SetActiveCharge | ( | integer | Charge | ) |
| EntityPlayer::SetCard | ( | integer | SlotId, |
| Card | Card | ||
| ) |
| EntityPlayer::SetFullHearts | ( | ) |
| EntityPlayer::SetMinDamageCooldown | ( | integer | DamageCooldown | ) |
| EntityPlayer::SetPill | ( | integer | SlotId, |
| PillColor | Pill | ||
| ) |
| EntityPlayer::SetShootingCooldown | ( | integer | Cooldown | ) |
| EntityPlayer::SetTargetTrapDoor | ( | GridEntity | TrapDoor | ) |
| EntityPlayer::ShootRedCandle | ( | Vector | Direction | ) |
for ghost pepper item + poop and farts
| EntityLaser& EntityPlayer::SpawnMawOfVoid | ( | integer | Timeout | ) |
| EntityPlayer::StopExtraAnimation | ( | ) |
| EntityPlayer::SwapActiveItems | ( | ) |
| boolean EntityPlayer::TryHoldTrinket | ( | TrinketType | Type | ) |
Returns true if an active item pickup cooldown is over. returns true if trinket can be added, else false
| EntityPlayer::TryRemoveCollectibleCostume | ( | CollectibleType | Collectible, |
| boolean | KeepPersistent | ||
| ) |
tries to remove a costume based on some filters
| EntityPlayer::TryRemoveNullCostume | ( | Config::NullItemID | NullId | ) |
| boolean EntityPlayer::TryRemoveTrinket | ( | TrinketType | Type | ) |
| EntityPlayer::TryRemoveTrinketCostume | ( | TrinketType | Trinket | ) |
tries to remove a costume based on some filters
| boolean EntityPlayer::TryUseKey | ( | ) |
| EntityPlayer::UpdateCanShoot | ( | ) |
| EntityPlayer::UseActiveItem | ( | CollectibleType | Item, |
| boolean | ShowAnim, | ||
| boolean | KeepActiveItem, | ||
| boolean | AllowNonMainPlayer, | ||
| boolean | ToAddCostume | ||
| ) |
| EntityPlayer::UseCard | ( | Card | Card | ) |
| EntityPlayer::UsePill | ( | PillEffect | PillEffect, |
| PillColor | PillColor | ||
| ) |
| boolean EntityPlayer::WillPlayerRevive | ( | ) |
| BabySubType EntityPlayer::BabySkin |
P2 Skin section Used to hold the selected skin (in case of glitched baby it will pick a random one)
| boolean EntityPlayer::CanFly |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. Can the player fly over rocks and pits?
| const integer EntityPlayer::ControllerIndex |
s32 GetItemStateCooldown( void ) const { return m_ItemStateCooldown; }
| integer EntityPlayer::ControlsCooldown |
| boolean EntityPlayer::ControlsEnabled |
| float EntityPlayer::Damage |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How much damage do the players tears or other main weapons do?
| integer EntityPlayer::FireDelay |
How long until the player can spawn their next tear?
| const EntityDesc& EntityPlayer::FriendBallEnemy |
| integer EntityPlayer::ItemHoldCooldown |
Used for avoiding player get stucked between rocks when switching a flying item with other active item.
| KColor EntityPlayer::LaserColor |
| float EntityPlayer::Luck |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. Better luck generally means better random events.
| integer EntityPlayer::MaxFireDelay |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How long between each tear can spawn?
| float EntityPlayer::MoveSpeed |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast can the player move?
| QueueItemData EntityPlayer::QueuedItem |
item queue for when the player is picking up an item. the item is in effect as soon as the animation is finished and will be removed from the queue.
| ActiveItemDesc EntityPlayer::SecondaryActiveItem |
| float EntityPlayer::ShotSpeed |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast does the tear travel when spawned?
| Vector EntityPlayer::SpriteScale |
| KColor EntityPlayer::TearColor |
| float EntityPlayer::TearFallingAcceleration |
| float EntityPlayer::TearFallingSpeed |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How fast is the tear moving up or down when it spawns? Affects range.
| integer EntityPlayer::TearFlags |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How much gravity does the tear have to start? Affects range.
| float EntityPlayer::TearHeight |
Player stat - Only change this in a callback to MC_EVALUATE_CACHE. How high above the ground is the tear when it spawns? Affects range.
| const Vector& EntityPlayer::TearsOffset |


How much do you know about what going on in the world this year? Take this 18 question quiz to see how well you kept up with current events of 2018!!


General Info
Status : {{gate_log.status.name}}
Customer Details
- Name Abdul
- Mobile No<PHONE_NUMBER>
- Email<EMAIL_ADDRESS>- Address No.102, Athipalayam Road, Chinnavedampatti, Coimbatore.
- GST No GS7878889999776
- PAN No B19899PL
- Ownership First


--- layout: index_layout title: Claire's Cybersecurity Corner // Donate ---
Thanks for wanting to donate!
My site does not require much to run- it's hosted on Github Pages (for free) and domain registration is about $10 a year.
Therefore, at this time I am not accepting donations, however, if you really would like to donate to me, donate to my friend's cause, TinyBird Games, instead!
Some info about TinyBird Games:
"TinyBird is an international small indie game dev based in Brazil. Started in july of 2016, our mission is to give opportunities to people from the LGBTQA community by providing a safe work environment and raising awareness to the general public.
We intend to support the LGBTQA community by providing jobs to their members, although intermittent freelance work, we can introduce them to a safe environment where they can start to learn and/or support themselves."
Main Site: http://www.tinybirdgames.com/
Patreon link: https://www.patreon.com/tinybirdgames
Thanks for the consideration!


We've taken all the work out of provisioning and managing cloud servers so you can focus on things you do best: building awesome PHP applications and websites.
We don't discriminate: Laravel, Symfony, Wordpress, Statamic, Craft, and any other PHP application can easily be installed on a Forge server.
We've taken all the work out of provisioning and managing cloud servers so you can focus on things you do best: building awesome PHP applications and websites.
We don't discriminate: Laravel, Symfony, Wordpress, Statamic, Craft, and any other PHP application can easily be installed on a Forge server.
Using a generic icon like an arrow or a checkmark instead of the standard bullet is a great way to add visual interest to unordered lists.
– Steve Schoger · 7 Jun 2017


How many military-grade assault rifles are in your state? Click on your state to find out detailed info about crime in YOUR community.
Heat Map: Darker blue states have higher military equipment donations, fatal police encounters, and violent crime, per capita.


Fortune Cookie
Main navigation
home
fortune cookie
about
Fortune Cookie
helps you identify future best sellers among new products. Please enter the Amazon Standard Identification Numbers (ASINs) to try it out!
Amazon product ASIN:
(e.g. B075WTP164, B074F2YGBF, B075MTSS8L)


One example of a data visualization using the internet is a video which shows multiple different graphs. Sometimes these visualizations will just be a series of graphs like the ones we've seen before. For example, the graph in Figure 5.6.21 showed the relationship between the gross domestic product (GDP) and CO2 emissions per person for countries in 2018. The video in Figure 5.6.31 shows the same data, but for every year from 1961 to 2014. It also adds another data set - how much the temperature in that country has gone up or down from the average over 1961-2018. The temperature change is represented by the color and size of the dot.
in-context


While music visualization in tabr
focuses on leveraging LilyPond to make tablature, some diagrams can also be drawn directly in R using ggplot without any need to involve LilyPond. The plot_fretboard
function makes standalone fretboard diagrams in R, independent of the LilyPond sheet music pipeline.
plot_fretboard
is a highly specialized function that takes vector inputs for string numbers and fret numbers and maps the combination element-wise to produce a fretboard diagram. Note that plot_fretboard
is a developmental function and the interface and arguments it provides may change.
The fretted notes are marked in the diagram using customary large circles.
The fretted notes can be labeled. labels
can be an arbitrary vector corresponding to the string and fret numbers. For example, you can label each circle with the fingerings used to play chords or scales.
If you set labels = "notes"
, this is a special setting that will label all points with their note names. This can be done automatically because providing string and fret numbers in conjunction with the tuning
argument gives full information about the notes along the guitar neck. plot_fretboard
transposes these internally. This means it will work automatically no matter what arbitrary tuning
you set. Here is an example that also displays the tuning.
string <- c(6, 6, 6, 5, 5, 5, 4, 4, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1)
fret <- c(2, 4, 5, 2, 4, 5, 2, 4, 6, 7, 9, 6, 7, 9, 7, 9, 10, 7, 9, 10)
plot_fretboard(string, fret, "notes", show_tuning = TRUE)
When labels = "notes"
, accidentals are displayed as flats by default. Set accidentals = "sharp"
to change.
X and Y limits are expressed in terms of the number of instrument strings and the span of frets. You can override the fret range that is derived from fret
:
The number of strings an instrument has is derived from tuning
and this generalizes the fretboard diagram possibilities further. The tuning now specifies a seven-string guitar. One note has been added on string seven:
The points (circles) can have border and fill color. The labels can also be colored separately. These arguments can be vectorized. Notice the open Am chord does not really have an open sixth string; it is muted. The zero is still given in order to specify where to notate, but the mute
argument is given with a logical vector that indicates this entry is muted.
am_frets <- c(c(0, 0, 2, 2, 1, 0), c(5, 7, 7, 5, 5, 5))
am_strings <- c(6:1, 6:1)
mute <- c(TRUE, rep(FALSE, 11))
# colors
idx <- c(2, 2, 1, 1, 1, 2, rep(1, 6))
lab_col <- c("white", "black")[idx]
pt_fill <- c("firebrick1", "white")[idx]
plot_fretboard(am_strings, am_frets, "notes", mute,
label_color = lab_col, point_fill = pt_fill)
group
can also be used for faceting. However, faceting is still a problematic feature. It may work well enough in cases where the different diagrams span similar frets. The presence of muted notes can also cause issues when faceting. plot_fretboard
works best for single-panel plots. Since the function returns a ggplot object, you can always make them separate plots and arrange in a grid layout rather than rely on within-plot faceting.
Note that plot_fretboard
accepts character inputs like those used throughout tabr
:
f <- "0 2 2 1 0 0 0 2 2 0 0 0"
s <- c(6:1, 6:1)
grp <- rep(c("Open E", "Open Em"), each = 6)
# colors
idx <- c(2, 1, 1, 1, 2, 2, 2, 1, 1, 2, 2, 2)
lab_col <- c("white", "black")[idx]
pt_fill <- c("firebrick1", "white")[idx]
plot_fretboard(s, f, "notes", group = grp, fret_range = c(0, 4),
label_color = lab_col, point_fill = pt_fill)
The direction and handedness can also be changed. Diagrams can be vertical or horizontal as well as left- or right-handed.
Here, titles are added to the ggplot objects with ggtitle
. Of course you can add onto ggplot objects returned by plot_fretboard
, but you are limited in what you can add on and must be careful to avoid overriding properties of layers plot_fretboard
has already specified.
The previous examples show a mix of using plot_fretboard
to make general fretboard diagrams that show scales, arpeggios and other patterns, as well as to produce chord diagrams of specific chords. It is easier to use plot_chord
for the latter. It is a wrapper around plot_fretboard
that takes a string representing a single chord in the simple fret format shown here.
idx <- c(1, 1, 2, 2, 2, 1)
fill <- c("white", "black")[idx]
lab_col <- c("black", "white")[idx]
plot_chord("xo221o", "notes", label_color = lab_col, point_fill = fill)
Leading x
is inferred if there are fewer fret values in the string than there are instrument strings, as inferred from the tuning
argument. plot_chord
takes all the same arguments as plot_fretboard
except that it takes chord
instead of string
and fret
and it does not use mute
because muted notes are indicated with an x
inside chord
.
Frets are assumed to be single-digit when provided as above. When any two-digit fret value occurs, you must provide the fret values as space- or semicolon-delimited. The latter is like LilyPond format, but a trailing semicolon is ignored if present.
In an effort to leave some flexibility to the user, and while these plotting functions remain under development, plotting multiple chords as a chord chart is intentionally handled separately on a case by case basis. Here is an example using a little extra ggplot2
, purrr
and gridExtra
. It also shows how you can tweak some layout settings to size and arrange elements nicely for your Rmd
file.
library(ggplot2)
library(purrr)
library(gridExtra)
chords <- c("02210", "32010", "0232", "133211", "022100")
id <- c("Am", "C", "D", "F", "E")
g <- map2(chords, id, ~{
plot_chord(.x, "notes", point_size = 8, fret_range = c(0, 4), accidentals = "sharp", asp = 1.25) +
ggtitle(.y)
})
grid.arrange(grobs = g, nrow = 2)
You can use marrangeGrob
instead of grid.arrange
if you want to split a larger set of chord diagrams onto multiple pages.


Emphasize & accentuate the narrative
2-3 minutes per slide
Its easy to write slides that are walls of text. But remember that as soon as you put something in front of your audience they'll start reading it. And in general, people are very bad at focusing on two things at once.
So remember, this is an example of a poorly constructed slide.
With text, less is more
Be careful with visuals
Stick to your narrative
Make sure you've timed yourself
Know your transitions
Know your material