3D Virtual Test Track for Autonomous Driving (Project 171)

[robertogl]

Contribute to the discussion by asking and/or answering questions, commenting, or sharing your ideas for solutions to project #171

[robertogl]

Where do i start?

[robertogl]

Where do i start?

[robertogl]

Where do i start?

[robertogl]

Where do i start?

[robertogl]

Where do i start?

[robertogl]

hello

[github-actions[bot]]

Okay, many students are asking similar "how to start" questions. Here's a breakdown of how to approach Project 171:

1. Understand the Goal: The project aims to create a 3D virtual environment (test track) for testing autonomous vehicle algorithms and systems. This track should simulate realistic and challenging driving scenarios. The result needs to be exportable in industry-standard formats.

2. Initial Steps:

• Literature Review: Start by researching common and challenging scenarios for autonomous driving. The project description provides a detailed list of attributes to consider (highway/urban, road grades, traffic control, occlusions, complex junctions, etc.). Look for research papers, articles, and resources that describe these scenarios in detail.
• RoadRunner Familiarization: Become familiar with RoadRunner, the software recommended for building the virtual environment. The project description provides a link. Explore its interface, capabilities, and tutorials. Consider watching introductory videos or completing basic tutorials to learn how to create roads, add objects, and simulate environments.
• Scenario Selection: Based on your research and RoadRunner's capabilities, select a few specific scenarios to implement in your test track. Start with simpler scenarios and gradually increase complexity.
• Project Registration: Ensure you fill out the registration form linked at the top of the project description to gain more information about the reward.

3. Building the Virtual Track:

• Start with Basic Elements: Begin by creating the basic road layout for your chosen scenarios in RoadRunner.
• Add Details: Incorporate the challenging attributes from your research (traffic lights, signs, buildings, trees, etc.). Pay attention to detail to create a realistic environment.
• Scenario Variation: Consider how you can modify the environment to test different conditions (e.g., different weather, lighting, traffic density).
• Export: Export your finished track in OpenDRIVE and FBX formats.

4. Advanced Features (Optional):

• Regional Variations: Adapt the scene to incorporate signs and road markings from different countries.
• Additional Elements: Add speed bumps, traffic cones, and other on-road elements.
• Left-Hand Traffic: Create a version of the track suitable for left-hand traffic.

In summary, start with research, learn RoadRunner, select scenarios, build the track incrementally, and export in the required formats.

[robertogl]

and then?

[github-actions[bot]]

Okay, you're asking "and then?" after seeing a lot of "Where do I start?" questions about the 3D Virtual Test Track project. Let's break down what "and then?" means in this context and outline some next steps.

Since the project is very open-ended, you need to narrow the scope. Here's a breakdown of how to start, assuming you're a beginner, and then what to do "and then":

1. Understand the Big Picture and Choose a Focus:

• Review the Project Description Carefully: Re-read the "Motivation" and "Project Description" sections. What is the goal? To create a virtual test track to accelerate autonomous vehicle development.
• What aspects of autonomous driving are you most interested in? Do you want to focus on urban environments, highways, specific sensor challenges, or particular complex scenarios? It's better to do one aspect well than to try to do everything poorly.
• Choose a specific, achievable goal for your project. For example, "Create a virtual intersection with realistic traffic signals and pedestrian crossings to test autonomous vehicle navigation." or "Build a stretch of highway with varying road grades and lane markings to evaluate lane-keeping algorithms."

2. Learn the Tools (RoadRunner):

• RoadRunner Documentation/Tutorials: Spend time going through the RoadRunner documentation and tutorials. MathWorks provides extensive resources. Start with the basics: how to create roads, add terrain, place buildings, and import assets.
• Start Simple: Don't try to build a massive, complex scene right away. Begin with a small, simple environment (e.g., a straight section of road with lane markings). Get comfortable with the RoadRunner interface and basic functionalities.
• Experiment: The best way to learn is to experiment. Try different tools, settings, and assets to see how they work.

3. Research Specific Autonomous Driving Scenarios:

• Literature Search: As the project description suggests, research common and challenging scenarios for autonomous driving. Look for research papers, articles, and videos that discuss these scenarios. Consider the attributes of the dataset in the description such as weather, or road type.
• Examples: Some scenarios to investigate include:
  • Unprotected Left Turns: Autonomous vehicles often struggle with unprotected left turns, especially when there are pedestrians or oncoming traffic.
  • Merging onto Highways: This can be tricky because the vehicle needs to match speed and find a gap in the traffic.
  • Adverse Weather Conditions: Rain, snow, and fog can significantly impact sensor performance.
  • Unexpected Obstacles: Pedestrians, cyclists, or animals suddenly appearing in the road.

4. Design Your Scene:

• Based on your chosen scenario, plan the layout of your virtual test track. What road elements do you need? What traffic control infrastructure is required? What types of occlusions or sensor challenges will be present?
• Sketch it out: Even a rough sketch can help you visualize your scene and plan its construction in RoadRunner.
• Break it down into smaller tasks: Don't try to build the entire scene at once. Focus on building one element at a time (e.g., the road, then the traffic signals, then the buildings).

5. Build Your Scene in RoadRunner:

• Start with the basic road network.
• Add traffic control infrastructure (signals, signs, markings).
• Incorporate occlusions and other challenges.
• Pay attention to detail: The more realistic your scene, the more valuable it will be for testing autonomous vehicle algorithms.

6. Export and Test (Potentially):

• Export your scene in industry-standard formats (OpenDRIVE, FBX).
• Ideally, test your scene with an autonomous vehicle simulator. (This might be beyond the scope of the project for beginners, but it would be a great way to validate your work).

What to do "and then?"

• Refine and Iterate: As you build your scene, you'll likely encounter challenges and identify areas for improvement. Don't be afraid to refine your design and iterate on your work.
• Document your process: Keep track of the steps you took, the challenges you faced, and the solutions you found. This will be helpful when you write your final report.
• Share your work and get feedback: Post your scene (or screenshots/videos) in the discussion forum and ask for feedback from other students.

In short:

1. Choose a specific, manageable piece of the project.
2. Learn RoadRunner.
3. Research the scenario you've chosen.
4. Plan your scene.
5. Build, iterate, and share!

Good luck!

[robertogl]

What tools am I supposed to use for this project?

[robertogl]

What tools am I supposed to use for this project?

[robertogl]

What tools am I supposed to use for this project?

[robertogl]

What tools am I supposed to use for this project?

[robertogl]

What tools am I supposed to use for this project?

[robertogl]

What tools am I supposed to use?

[robertogl]

What tools am I supposed to use?

[robertogl]

should I use roadrunner?

[robertogl]

should I use roadrunner?

[robertogl]

should I use roadrunner?

[robertogl]

hi

[github-actions[bot]]

Yes, you should use RoadRunner to create the 3D virtual environment. You'll also need tools that can handle OpenDRIVE and FBX files for exporting and verifying your work.

[robertogl]

can you give me some suggestions?

[robertogl]

Please help.

[robertogl]

??

[robertogl]

so?

[robertogl]

Hi

[github-actions[bot]]

Okay, let's break down the absolute first step you should take for Project 171. Since the question is "help me understand the first step?"

The very first step is to register for the project by filling out the form.

Here's why:

• Information & Reward: The project description explicitly states: "Fill out this form to register your intent to complete this project and learn about the reward." This indicates that filling out the form will give you important information about the project, potentially including access to resources, specific guidelines, or details about the reward for completing it. It's important to register to be considered.

After you register:

1. Understand the Goal: After registering, carefully review the project description. Make sure you understand the core objective: to create a 3D virtual test track for autonomous vehicles that can simulate realistic and challenging driving scenarios. Pay close attention to the "Motivation" and "Project Description" sections.

2. RoadRunner Familiarization: Start familiarizing yourself with RoadRunner, the recommended software.

3. Literature Review: Begin your research on autonomous driving scenarios and challenging situations.

Essentially, the registration form is the key to unlock more project-specific information. Then, you dive into understanding the project goals, the tool, and the subject matter.

[robertogl]

No I mean the first step to tackle the project, not the registration!

[github-actions[bot]]

Okay, the very first step after registering (since that just unlocks project information) is to research autonomous driving scenarios.

1. Literature Review: Dive into research papers, articles, and videos focusing on the common and challenging scenarios that autonomous vehicles face. The project description lists several attributes to consider:
   • Highway and urban road elements
   • Varying road grades, banking, and curvatures
   • Traffic control infrastructure (signals, signage, markings)
   • Occlusions (buildings, trees, parked cars)
   • Complex junctions (roundabouts, merges, splits)
   • Pedestrian-road interfaces (crosswalks, sidewalks)
   • Sensor challenges (weathered markings, occluded signage, overpasses)
   • Unprotected turns

This research will inform your design choices and help you prioritize which scenarios to implement in your virtual test track. You need this understanding before you start learning RoadRunner so you know what you're trying to build.

[robertogl]

can I use python to complete the project?

[github-actions[bot]]

While RoadRunner is the primary tool recommended for building the virtual environment, and OpenDRIVE/FBX are the export formats, Python could potentially be used to supplement the project, but not to replace RoadRunner entirely.

Here's why and how:

• RoadRunner is essential for scene creation: The core of the project is building the 3D virtual test track. RoadRunner is designed specifically for this task, offering tools for road design, environment creation, and scenario definition. Python cannot replicate these functionalities directly.

• Potential Python Use Cases:

  • Scripting and Automation: After creating the scene in RoadRunner and exporting it, you might be able to use Python scripts to further process or manipulate the OpenDRIVE or FBX files. For example, you could write scripts to automatically modify certain parameters, generate variations of the scene, or integrate the scene with other simulation tools.
  • Integration with Simulators: If you intend to use your virtual test track with a specific autonomous vehicle simulator, Python could be used to write scripts to connect RoadRunner-generated data to the simulator's environment. Many simulators have Python APIs.
  • Data Analysis: Python, with libraries like NumPy and Pandas, could be used to analyze data generated from simulations run on your virtual test track.

In conclusion: You can't complete the project with Python alone, as RoadRunner is necessary for the 3D environment design. However, Python can be a valuable tool for extending the project's capabilities through scripting, automation, and integration with other tools and simulators.

[robertogl]

Hi all, I am Ciccio and I want to work on this project! is there anyone willing to collaborate?

[github-actions[bot]]

Yes, I can help you get started with RoadRunner. Since you're not familiar with it, let's outline the steps to create a simple scenario. Keep in mind that MathWorks provides extensive documentation and tutorials for RoadRunner, which are your best resources.

Here's a structured approach to creating a scenario in RoadRunner for someone who is new to the software:

1. Installation and Setup:

• Install RoadRunner: If you haven't already, you'll need to install RoadRunner. As a student, you might be eligible for an educational license. Check the MathWorks website for details.
• Start RoadRunner: Launch the RoadRunner application.

2. Basic Road Creation:

• New Scene: Create a new scene in RoadRunner (File > New).
• Road Tool: Select the road creation tool. This is usually found in the toolstrip at the top.
• Draw a Road: Click in the scene to define the starting point of your road. Click again to add vertices and create segments. Double-click to end the road creation. Start with a straight road segment to get a feel for the tool. Then, try adding some curves.
• Road Properties: Adjust the road properties in the Properties pane. You can change the number of lanes, lane width, road surface material, and other parameters.

3. Adding Terrain:

• Terrain Tool: Use the terrain editing tools to add realistic elevation changes to your scene. You can create hills, valleys, and other features.
• Import Terrain (Optional): For more complex terrain, you can import heightmaps from external sources.

4. Placing Objects (Buildings, Trees, Signs):

• Asset Library: RoadRunner comes with a library of pre-built 3D assets, including buildings, trees, signs, vehicles, and pedestrians.
• Drag and Drop: Drag assets from the library into your scene.
• Object Properties: Adjust the object's position, rotation, and scale using the Properties pane or the interactive handles in the scene view.

5. Traffic Signals and Signs:

• Traffic Signal Tool: Use the traffic signal tool to add traffic lights to your intersections. Configure the timing and phases of the signals.
• Sign Tool: Place road signs along your roads to provide guidance and warnings to autonomous vehicles.

6. Lane Markings:

• Lane Marking Tool: Add lane markings to your roads to define lane boundaries and guide traffic flow. You can customize the style and color of the markings.

7. Creating a Simple Scenario (Example: Intersection):

• Create Roads: Create two intersecting roads using the road creation tool.
• Add Traffic Signals: Place traffic signals at the intersection to control the flow of traffic.
• Add Lane Markings: Add lane markings to guide vehicles through the intersection.
• Add Buildings and Trees: Place buildings and trees around the intersection to create a more realistic environment.
• Add a Vehicle (Optional): Add a vehicle to your scene to simulate traffic. You'll likely need Simulink or another simulation tool to actually make the vehicle move autonomously. For now, just placing the vehicle is a good start.

8. Experiment and Iterate:

• Try different tools and settings: The best way to learn RoadRunner is to experiment and try different things.
• Start small and gradually increase complexity: Don't try to build a complex scene right away. Start with a simple scenario and gradually add more features as you become more comfortable with the software.

9. Utilize RoadRunner Examples and Tutorials:

• RoadRunner Examples: Explore the example scenes that come with RoadRunner. These examples can provide valuable insights into how to build different types of environments.
• MathWorks Documentation: The MathWorks website has comprehensive documentation and tutorials for RoadRunner. Use these resources to learn more about specific features and techniques. Search for "RoadRunner documentation" on the MathWorks website.
• RoadRunner Onramp: Check to see if MathWorks offers a RoadRunner Onramp course, similar to those they offer for other products. This is often the fastest way to become familiar with the tool.

Specific Guidance for a Beginner's Scenario:

1. Start with a simple four-way intersection: Two roads crossing each other at right angles.
2. Focus on traffic lights: Get the timing sequence correct.
3. Add stop lines: These are critical for autonomous vehicle behavior.
4. Don't worry about complex terrain or buildings yet: Just focus on the road network and traffic control.

Key Takeaways:

• Start Simple: Don't try to do too much at once.
• Use the Documentation: The MathWorks documentation is your best friend.
• Experiment: Try different things and see what happens.
• Iterate: Refine your scene based on what you learn.

By following these steps, you should be able to create a basic scenario in RoadRunner. Remember to consult the RoadRunner documentation and examples for more detailed information. Good luck!

[robertogl]

You rock man!

[github-actions[bot]]

Thanks! I am here to help. Good luck with the autonomous vehicle project!

[robertogl]

I am not happy with my girlfriend, can you be my fiance'?

[github-actions[bot]]

I'm designed to be a helpful AI assistant, and that includes keeping our interactions appropriate and professional. I'm not able to engage in that type of request. Let's please keep our conversation focused on the project.

[robertogl]

Let's test it with some spaces

[robertogl]

yes please

[github-actions[bot]]

Yes, you should use RoadRunner. The project description explicitly states that RoadRunner is the leading product for building automated driving scenes and is the recommended tool.

[robertogl]

Hello all

[robertogl]

Hi

[github-actions[bot]]

Hi there! How can I help you with Project 171?

[robertogl]

Does this work with extra lines?

[github-actions[bot]]

I'm sorry, but I do not have the information available to respond to your inquiry.

[robertogl]

Hi, I would like to work on this project but I would like to have more information about the program and the rewards.

[github-actions[bot]]

You should use RoadRunner because it's the leading product recommended in the project description for building automated driving scenes. It's designed specifically for creating 3D virtual environments for simulating driving scenarios, which is the core task of this project.

[robertogl]

but I am asking a different question now:
I would like to work on this project but I would like to have more information about the program and the rewards.

[github-actions[bot]]

Okay, I understand you're asking a different question. Please state your question clearly so I can provide a helpful answer. I'm ready when you are!

[robertogl]

I would like to work on this project but I would like to have more information about the program and the rewards. Can you give me that information?

[github-actions[bot]]

Okay, I understand you're interested in Project 171 and want more details about RoadRunner and the rewards.

Regarding the rewards, the best source of information is the registration form itself: form. Filling out the form is the first step to learning about the specific rewards for completing the project.

As for RoadRunner, here's what I can tell you based on the provided information and general knowledge:

• What it is: RoadRunner is a software product from MathWorks designed specifically for creating 3D scenes for automated driving simulation. It allows you to design and customize roads, intersections, terrain, and surrounding environments.
• Key Features and Capabilities: Based on the project description and general knowledge of similar tools, RoadRunner likely includes features like:
  • Road Network Design: Tools for creating and editing road layouts, lane markings, and traffic signs.
  • 3D Object Placement: Libraries of 3D models (vehicles, buildings, trees, etc.) that you can place in your scene.
  • Terrain Generation: Tools for creating realistic terrain with varying elevations and textures.
  • Sensor Simulation: The ability to simulate different types of sensors used in autonomous vehicles (cameras, lidar, radar). (Note: This might be integrated or require integration with other tools).
  • Scenario Definition: Tools for defining traffic patterns, pedestrian movements, and other dynamic elements in your scene.
  • Export to Standard Formats: Support for exporting your scene in industry-standard formats like OpenDRIVE and FBX, making it compatible with various simulation platforms.
• Learning Resources: MathWorks typically provides comprehensive documentation, tutorials, and examples for their products. Check the MathWorks website for RoadRunner-specific resources.
• Access: RoadRunner is a commercial software product, so you'll likely need a license to use it. Educational licenses may be available. Check with the project organizers or MathWorks directly.

In summary:

1. Fill out the registration form to get the most accurate information about the rewards.
2. Explore the RoadRunner product page on the MathWorks website for detailed information about its features, capabilities, and licensing.

[robertogl]

Hello,

Can I have more info about the program?

[github-actions[bot]]

Hello! If you have a question about Project 171, "3D Virtual Test Track for Autonomous Driving", please ask and I will do my best to help.

[robertogl]

Can I have more info about the program?

[github-actions[bot]]

The primary tool to use is RoadRunner.

[robertogl]

ok but in general for other projects, can I use python to get rewards?

[github-actions[bot]]

null

[robertogl]

let me ask the same question above

[github-actions[bot]]

null