Adjust the sensor settings

Oct 13, 2025 by pynkocean.com 112 views

Introduction

CARLA (Car Learning to Act) is a popular open-source simulator for autonomous driving. It provides a realistic and flexible environment for testing and training AI models. However, users have reported an issue with the radar sensor in CARLA, where it detects many points on the ground in front of the vehicle. This behavior is not expected, as radar signals are not supposed to strongly reflect off the ground under normal conditions. In this article, we will investigate this issue and explore possible solutions.

Understanding the Radar Sensor

The radar sensor in CARLA is a 4D sensor that detects objects in the environment based on their speed, azimuth, altitude, and depth. It is designed to provide accurate and reliable data for autonomous driving applications. However, the radar sensor's performance can be affected by various factors, such as the environment, sensor settings, and data processing.

Investigating the Issue

To investigate the issue, we need to reproduce the problem and analyze the data. We can do this by creating a radar sensor and setting its attributes, creating an RGB camera sensor, and projecting the radar points on the RGB image. We can then examine the resulting image and identify the points that are detected on the ground.

Steps to Reproduce the Issue

Create a radar sensor and set its attributes.
Create an RGB camera sensor.
Project the radar points on the RGB image.

Expected Behavior

The expected behavior is that the radar sensor should filter out ground-based radar points that are not well reflected. This means that the radar sensor should only detect points that are above a certain threshold, such as the height of the vehicle.

Possible Solutions

There are several possible solutions to this issue:

Adjust the sensor settings: We can adjust the sensor settings to improve the accuracy of the radar sensor. This may involve adjusting the horizontal and vertical fields of view, the points per second, and the range.
Implement a ground filtering algorithm: We can implement a ground filtering algorithm to remove points that are detected on the ground. This may involve using a threshold value to determine whether a point is above or below the ground.
Use a more advanced radar sensor model: We can use a more advanced radar sensor model that takes into account the environment and sensor settings. This may involve using a physics-based model or a machine learning-based model.

Code Modifications

To implement the solutions, we need to modify the code that projects the radar points on the RGB image. We can do this by adding a ground filtering algorithm or adjusting the sensor settings.

# self.args.radar = [90.0, 2000, 80, 0, 20.0]
bp = world.get_blueprint_library().find('sensor.other.radar')
# 設定藍圖參數
attributes = ['horizontal_fov', 'points_per_second', 'range', 'sensor_tick', 'vertical_fov']
radar_attribute_str = 'Radar params: '
for idx, attribute in enumerate(attributes):
      bp.set_attribute(attribute, str(self.args.radar[idx]))

# ...

def get_radar_local(alt, azi, depth):
    x = depth * math.cos(alt) * math.cos(azi)
    y = depth * math.cos(alt) * math.sin(azi)
    z = depth * math.sin(alt)

    return [x, y, z]

def get_radar_local_to_world(xyz_local, r2w):
    x, y, z = xyz_local[0], xyz_local[1], xyz_local[2]
    
    radar_local = np.array([x, y, z, 1])
    radar_world = np.dot(r2w, radar_local)
    
    return radar_world

def get_camera_world_to_local(xyz_world, w2c):
    return np.dot(w2c, xyz_world)

# (u, v)
def get_image_point(cam_loc, K):
    point_camera = np.array([cam_loc[1], -cam_loc[2], cam_loc[0]])
    point_image = np.dot(K, point_camera)
    point_image[0] /= point_image[2]
    point_image[1] /= point_image[2]

    return point_image[:2]

rdr = np.copy(np.frombuffer(radar_data.raw_data, dtype=np.dtype('f4')))
rdr = np.reshape(rdr, (len(radar_data), 4))
# (vel, azimuth, altitude, depth)    
for (vel, azimuth, altitude, depth) in rdr:
        radar_local = get_radar_local(altitude, azimuth, depth)
        radar_matrix = g_radar_sensor.get_transform().get_matrix()
        radar_local_to_world = get_radar_local_to_world(radar_local, radar_matrix)
        camera_inverse_matrix = g_camera_sensor.get_transform().get_inverse_matrix()
        camera_world_to_local = get_camera_world_to_local(radar_local_to_world, camera_inverse_matrix)
        image_point = get_image_point(camera_world_to_local, K)
        if (round(image_point[0])<0) or (round(image_point[0])>=rgb_image_data.width) or (round(image_point[1])<0) or (round(image_point[1])>=rgb_image_data.height):
                continue
        # Add ground filtering algorithm here
        if image_point[1] < 0.5 * rgb_image_data.height:
                continue
        cv2.circle(rgb_img, center=(round(image_point[0]), round(image_point[1])), radius=1, color=(0, 0, 255), thickness=-1)   
cv2.imshow("Windows2Check", rgb_img)

Conclusion

In conclusion, the issue with CARLA's radar detecting many points on the ground is a complex problem that requires a thorough investigation and analysis. By reproducing the problem and examining the data, we can identify the root cause of the issue and implement solutions to improve the accuracy of the radar sensor. The possible solutions include adjusting the sensor settings, implementing a ground filtering algorithm, and using a more advanced radar sensor model. By modifying the code and implementing these solutions, we can improve the performance of the radar sensor and provide more accurate data for autonomous driving applications.

Future Work

Future work includes:

Investigating the effect of different sensor settings on the radar sensor's performance
Implementing a more advanced radar sensor model that takes into account the environment and sensor settings
Testing and evaluating the performance of the radar sensor in different scenarios and environments

References

CARLA documentation: https://carla.readthedocs.io/en/latest/
Radar sensor documentation: https://carla.readthedocs.io/en/latest/sensors/radar_sensor/
Ground filtering algorithm documentation: https://carla.readthedocs.io/en/latest/sensors/ground_filtering_algorithm/

Q: What is the issue with CARLA's radar detecting many points on the ground?

A: The issue with CARLA's radar detecting many points on the ground is that it is not filtering out points that are detected on the ground. This can lead to inaccurate data and affect the performance of autonomous driving applications.

Q: Why is this issue a problem?

A: This issue is a problem because it can lead to inaccurate data and affect the performance of autonomous driving applications. For example, if the radar sensor is detecting many points on the ground, it may not be able to accurately detect obstacles or pedestrians, which can lead to accidents.

Q: How can I reproduce the issue?

A: To reproduce the issue, you can create a radar sensor and set its attributes, create an RGB camera sensor, and project the radar points on the RGB image. You can then examine the resulting image and identify the points that are detected on the ground.

Q: What are some possible solutions to this issue?

A: Some possible solutions to this issue include adjusting the sensor settings, implementing a ground filtering algorithm, and using a more advanced radar sensor model.

Q: How can I adjust the sensor settings to improve the accuracy of the radar sensor?

A: You can adjust the sensor settings by changing the horizontal and vertical fields of view, the points per second, and the range. You can also adjust the sensor's sensitivity and noise reduction settings.

Q: What is a ground filtering algorithm, and how can I implement it?

A: A ground filtering algorithm is a technique used to remove points that are detected on the ground. You can implement a ground filtering algorithm by using a threshold value to determine whether a point is above or below the ground.

Q: What is a more advanced radar sensor model, and how can I use it?

A: A more advanced radar sensor model is a model that takes into account the environment and sensor settings. You can use a more advanced radar sensor model by implementing a physics-based model or a machine learning-based model.

Q: How can I test and evaluate the performance of the radar sensor in different scenarios and environments?

A: You can test and evaluate the performance of the radar sensor in different scenarios and environments by using a variety of testing tools and techniques. You can also use simulation software to simulate different scenarios and environments.

Q: What are some common issues that can affect the performance of the radar sensor?

A: Some common issues that can affect the performance of the radar sensor include:

Noise: Noise can affect the accuracy of the radar sensor by introducing false readings.
Interference: Interference from other sensors or devices can affect the performance of the radar sensor.
Environmental factors: Environmental factors such as weather, lighting, and terrain can affect the performance of the radar sensor.
Sensor settings: Incorrect sensor settings can affect the performance of the radar sensor.

Q: How can I troubleshoot issues with the radar sensor?

A: You can troubleshoot issues with the radar sensor by:

Checking the sensor settings: Make sure that the sensor settings are correct and optimal for the environment and scenario.
Checking for noise and interference: Check for noise and interference that may be affecting the performance of the radar sensor.
Checking the environmental factors: Check the environmental factors such as weather, lighting, and terrain that may be affecting the performance of the radar sensor.
Checking the sensor itself: Check the sensor itself for any issues or defects.

Q: What are some best practices for using the radar sensor in autonomous driving applications?

A: Some best practices for using the radar sensor in autonomous driving applications include:

Using a high-quality radar sensor: Use a high-quality radar sensor that is designed for autonomous driving applications.
Adjusting the sensor settings: Adjust the sensor settings to optimize the performance of the radar sensor for the environment and scenario.
Implementing a ground filtering algorithm: Implement a ground filtering algorithm to remove points that are detected on the ground.
Using a more advanced radar sensor model: Use a more advanced radar sensor model that takes into account the environment and sensor settings.