Last week I spent about 25 minutes driving around three blocks looking for a parking spot. I went around the same streets more than once, checking every gap between parked cars. At one point I was pretty sure I had already driven past an empty space, but I couldn't remember where it was, so I did another lap.
The frustrating part was that the information I needed was already there. The car was looking at the street the whole time. I just didn't have a good way of turning what it saw into something useful.
That made me think: what if the cars driving around a city could collectively become a network of parking sensors?
That's the idea behind ParkSight.
A car equipped with a dashcam and an Axelera Metis card could detect parking opportunities as it drives and send those observations to a shared map. With enough participating vehicles, the map could continuously update as cars pass through the city.
There is also a more structured version of the same idea: install ParkSight on city buses or other vehicles that already follow regular routes. Instead of installing sensors on every street, the vehicles themselves become the sensing infrastructure.
What the demo will look like
For the challenge, I'll build the vehicle-side system and simulate the larger network using several recorded routes.
A dashcam will provide 1080p video at around 30 FPS. The video will be processed locally on the Dell XE5 using the Axelera Metis PCIe card.
The system will detect vehicles and understand the surrounding street scene, then use those outputs to identify gaps along the curb that could be parking spaces.
Each candidate will be associated with a GPS position and timestamp and turned into a parking observation. For the demo, observations from several routes will be combined into one map.
So the basic flow is:
drive around → detect parking → attach a location → add it to the map.
How it works
I'll start with two models running on Metis:
- YOLO11s for vehicle detection.
- DeepLabV3+ for semantic segmentation of the street scene.
I chose DeepLabV3+ because its strong Cityscapes segmentation performance makes it a promising candidate for understanding road and sidewalk boundaries, which are important for identifying parking gaps. It isn't currently a ready-to-use model in the Axelera Model Zoo, so I'll use Wingman to see if it can be compiled for Metis or adapted if necessary. If that becomes too time-consuming, U-Net FCN 512, which is already supported, is the fallback.
The two models provide complementary information. YOLO11s tells me where the vehicles are, while the segmentation model gives me the surrounding road and sidewalk geometry. The host-side Python application will combine those outputs to:
- Find the road/sidewalk boundary.
- Identify vehicles positioned along that boundary.
- Estimate gaps between vehicles.
- Reject gaps that are obviously too small.
- Filter obvious driveways, crossings and other non-parking areas where possible.
- Give each candidate a confidence score.
- Attach GPS coordinates and a timestamp.
- Produce a parking observation for the map.
I also want to take advantage of Metis' ability to run the perception models in parallel rather than processing them one after another. The goal is not simply to increase FPS, but to reduce the delay between capturing a frame and producing the combined perception result. Since the vehicle is moving, that makes it easier to match what the camera saw with the correct GPS position.
This is where Voyager Wingman becomes useful. I'll use it first to get the perception models running on Metis, and then to build the application around their outputs.
Building the demo
I'll build the demo in a few steps.
1. Get the perception pipeline running
I'll use Wingman to get YOLO11s and DeepLabV3+ running from the same dashcam input. I'll see whether DeepLabV3+ compiles directly and adapt it if necessary, with U-Net FCN 512 as the fallback.
2. Build the parking logic
I'll take the model outputs into a Python application and implement the basic parking logic: finding the road/sidewalk boundary, associating vehicles with the curb, measuring gaps and filtering obvious false positives.
3. Add location
I'll synchronize the detections with GPS data so that every parking candidate becomes a timestamped, located observation.
4. Build the map
I'll display those observations on an interactive map and process several recorded routes as if they came from different vehicles.
5. Test it on real streets
I'll use a busy commercial street, a residential street and a mixed-use street with driveways and crossings. I'll deliberately look for situations that confuse the system and improve the filtering where necessary.
6. Put the demo together
The final demo will show the original street footage, the perception and parking detections, and the resulting map being populated by observations from multiple routes.
I'll document the Wingman prompts and iterations, clean up the repository and include the configuration and instructions needed to reproduce the project.
Thank you for reading through !
If ParkSight works, maybe the next time I drive around looking for parking, I won't have to spend 25 minutes doing laps around the block.
And that's probably the best part: 25 minutes saved every time I park means 25 more minutes to work on whatever I build on Metis next.
So hopefully ParkSight helps me spend less time looking for a place to stop and more time finding things to build !
The starting prompts
Rather than asking Wingman to build the entire project in one go, I want to split the build into two stages. The first is getting the perception models onto Metis. The second is building the application around the outputs of that pipeline.
Prompt 1 : Port the perception models to Metis
I want to build the perception stage of a real-time street parking detection system using an Axelera Metis PCIe card.
The input will be dashcam video.
I want to start with two models:
1. YOLO11s for vehicle detection. I need bounding boxes and class labels for cars, trucks, motorcycles and bicycles.
2. DeepLabV3+ for semantic segmentation of the street scene. I am particularly interested in the road, sidewalk, building and vegetation classes.
First, I want to get both models running on Metis from the same video input.
For DeepLabV3+, try to compile and run the model as provided. If there are unsupported operations or other compatibility problems, identify them and suggest what would need to be adapted to make it compatible with Metis.
If DeepLabV3+ cannot be made practical, suggest U-Net FCN 512 as the fallback, since it is already supported in the Axelera model zoo.
I want the two models to run in parallel where possible so that both perception outputs are available with minimal delay from the original camera frame.
Please build and configure the Metis pipeline so that both model outputs are available to a host-side Python application.
Keep the pipeline configuration reproducible and explain any model adaptations, compilation issues, host fallbacks or important decisions made along the way.
Prompt 2 : Build the ParkSight application
I now have the perception stage of my street parking detection system running on Metis.
The pipeline provides:
- YOLO11s vehicle detections with bounding boxes and classes
- Semantic segmentation of the street scene
- The two outputs generated from the same dashcam input
I want to build the host-side Python application that turns these outputs into parking observations.
The application should:
1. Identify the road/sidewalk boundary from the segmentation output.
2. Determine which detected vehicles are positioned along the curb.
3. Estimate the gaps between vehicles along the curb.
4. Reject gaps that are obviously too small to be parking spaces.
5. Use the segmentation geometry to filter obvious driveways, crossings, side streets and other areas that should not be treated as parking spaces where possible.
6. Assign a confidence score to each parking candidate.
7. Associate each candidate with the vehicle's GPS coordinates and timestamp.
8. Produce a parking observation containing at least the location, timestamp, confidence and estimated parking-space information.
9. Display the observations on a map.
The application should be able to process multiple recorded vehicle routes and combine their observations into the same map.
Please structure the application so that the Metis perception pipeline and the parking/map logic are separate components. I want to be able to change the perception models later without rewriting the parking application.
Please provide the Python application, configuration and instructions needed to run it with the Metis pipeline outputs.
