Posted on

Team’s status report for 3/8/25

The most significant risks have remained unchanged, with it being the delay of MVP. These risks are being mitigated by having spare components ordered from ECE inventory to substitute instead of our actual desired components. In terms of contingency plans, there are none, as MVP is a crucial step that cannot be circumvented in any way. However, we are testing the parts of our design as they finish, so we are confident that they will work as we assemble them into an MVP.

We made a few changes to the system design. We updated the cloud reliability target from 95% to 97% to reduce downtime risks and ensure timely database lookups for license plate matching, as AWS’s baseline uptime guarantee is closer to 95%. This is pretty realistic and also follows the published statistics for server uptime on AWS and shouldn’t change our costs. We also refined the edge-to-cloud processing pipeline to improve accuracy and efficiency. Both high and low-confidence detections are sent to the cloud, but low-confidence results also include an image for additional verification using more complex models. This change ensures that uncertain detections receive extra processing while still keeping the system responsive and scalable.

This will not significantly alter the current schedule, as lowering the accuracy requirement will make training easier and potentially quicker.

In addition, we have written the code for using the ML models on the raspberry pi and it can be found here.

Part A (Richard):

Our design should make the world a safer place with regards to child kidnapping. Our device, if deployed at scale, will be able to locate the cars of suspected kidnappers using other cars on the road quickly and effectively, allowing law enforcement to act as fast as possible. While we currently only plan on using the device with amber alerts, a US system, the design should largely work in other countries. The car and license plate detection models are not trained on the cars and plates of any specific country, and PaddleOCR supports multiple languages (over 80) if needed with foreign plates. This means that if other countries have a similar system to amber alerts, they can use our design as well. Our device may also motivate other countries who do not have a similar system to start their own in order to use our design and better find suspected kidnappers in their country.

Part B (Tzen-Chuen):

CALL sits at a conflicting cross-section of cultural values. Generally, our device seeks to protect children, a universal human priority. It accomplishes this through a distributed surveillance network, akin to the saying “it takes a village to raise a child.” By enabling a safer, more vigilant nation, we are in consideration of a global culture.

In terms of traditional “American values,” CALL presents a privacy problem. While not explicitly a constitutional right, it is implied in the 4th amendment. A widespread surveillance network is bound to raise concerns among the general public. We attempt to mitigate this concern by only sending license plate matches that have a certain confidence level to the cloud, and never to the end users. This way we balance the shared cultural understanding of child protection with the American tradition of privacy.

Part C (Eric):

Our solution minimizes environmental impact by leveraging edge computing, which reduces reliance on energy-intensive cloud processing, lowering power consumption and data transmission demands depending on the confidence of the edge model output. The system runs on a vehicle’s 12V power source, eliminating the need for extra batteries and reducing electronic waste. Additionally, its modular design makes it easy to repair and update, extending its lifespan compared to full replacements. These considerations ensure efficient operation while reducing the system’s environmental footprint.

Posted on

Richard’s status report for 3/8/25

This week I worked on deploying the ML models to the raspberry pi. This consisted of setting up the python environment, converting the Jupyter notebook into a standard python file, and setting up the file structure the raspberry pi will use. Since the notebook displays the bounding boxes and images when inferencing, when converting to a python file, I removed this code for faster performance since the end user will not see this anyway. I tested this implementation with a sample image that had two license plates in plain view. This is the same image used when testing the Jupyter notebook in Google colab. The program ran in just over 23 seconds, which should be plenty fast enough for our 40 second timing requirement. The models I used were the NCNN models but no quantization was used, so this number can be easily lowered further if needed. The code can be found here. When setting up the file system, I put the pictures and models into their own folders to easily switch between models and the images I test. Last week I worked on the design report, where I focused on the system implementation as well as the design trade studies.

My progress is on schedule. By next week I hope to finalize the MVP of the dashcam side of things, and shift focus to setting up the cloud

Posted on

Tzen-Chuen’s Status Report for 3/8

This week I configured the raspberry pi. This included installing a new headless OS for improved performance, and configuring the IPv4 address to allow for remote ssh. This allows us to set the raspberry pi up on CMU wifi and let us ssh into it to program it from wherever we are. The github repo is now also installed on it and progressing towards basic integration.

I didn’t get to creating a table and linking supabase to a user interface yet, but I have been looking into setting it up on a github domain. Now instead of zero cameras we have two cameras, and one cable to test the feedback from the other similar group that we may not have the requisite resolution.

Another significant part of the work this past week was the design report. I handled the Introduction and Project management sections, along with the Testing and Verification sections. While the design report seemed simple on its surface, actually putting every idea down in writing had a very clarifying effect on the overall direction of the project.

Progress is on schedule and now that all major components are here progress will go even smoother.

Posted on

Eric’s Status Report for 3/8/25

This week, I mainly focused on refining and updating the design report, specifically working on the Use-Case Requirements, Architecture and/or Principle of Operation, and Design Requirements sections. Some specific changes I made are:

  • Architecture and/or Principle of Operation: I refined the block diagram and system interactions, ensuring that the data flow from image capture → edge processing → cloud verification → database matching was clearly structured. I also improved the documentation/planning of how the edge processor filters and sends high and low-confidence detections to the cloud, reducing unnecessary bandwidth use.
  • Design Requirements: The biggest change since the Design presentation was updating the cloud reliability target. After reviewing existing cloud service reliability standards, I adjusted the uptime requirement from 95% to 97% to strike a balance between AWS’s guaranteed availability and real-world reliability needs. This change ensures that the system remains operational and responsive in high-demand scenarios, reducing the likelihood of missed detections due to cloud downtime.

I also worked with Richard to further define how the cloud infrastructure handles license plate matching and how that would be implemented, specifically using Supabase and AWS Sagemaker. My progress is on schedule, and we have begun testing timing on the Rpi. Next week I plan to continue working with Richard on testing the models on the Rpi, and hopefully begin testing using images from the camera module.

Posted on

Team’s Status Report for 2/22/25

Currently the most important risks that could jeopardize the success of our project is the MVP being delayed by any reason, as getting the MVP off the ground and tested will reveal any weak points that we need to address. The MVP being delayed will likely mean we will be time crunched when trying to iterate. 

We made a modification to the timing requirements based on further research into the Amber Alert use case after receiving feedback. Initially, the system was designed with a 60-second processing requirement, which aligns with the average lane change frequency on highways (2.71 miles). However, after analyzing worst-case merging scenarios, which would require about 20 seconds, we found 40 seconds would be a more appropriate constraint for the MVP to shoot for as a middle ground between these two cases, which once achieved, we would continue to target that worst-case timing requirement. This would better ensure timely license plate detection before a vehicle potentially exits the field of view. This wouldn’t have any direct costs, but it may affect the requirements we have on the processor, depending on how long it takes to do model inferencing.

Another change we are making is moving to supabase for our backend server, as it presents a much more user-friendly interface for our use case targets (law enforcement, amber alert) and is more setup-friendly.

Our schedule has not changed.

In addition, we have worked on our camera to OCR pipeline, and have made two versions of the code we will use: version 1, version 2.

Posted on

Richard’s Status Report for 2/22/25

This week I worked on the presentation with Tzen-Chuen and Eric, especially with regard to the details of the implementation, such as using YOLOv11 and AWS Lambda in our final design. In addition, I worked with Eric on setting up the pipeline of YOLOv11 to PaddleOCR. I made two versions of the pipeline, one that first detects cars and crops those images, then into license plate detection and cropping, then finally PaddleOCR to read the license plate. The second one does not do the initial car cropping and goes straight into license plate detection. The google colabs can be found here and here. I also did some more research on how to deploy the models to the raspberry pi, and found that we should use NCNN models. For our mvp, we will use a python script that I am working on running on a headless os using the optimized models. As soon as the camera arrives, we should be able to make a basic MVP excluding the cloud server.

My progress is on schedule. By next week, we hope to have a dash cam module MVP and get metrics on the initial performance of the device.

Posted on

Tzen-Chuen’s Status Report for 2/22/25

This week had a spanner thrown into the plans. On top of a very important presentation for EPP that took more time out of my week than usual, the design presentation unveiled new considerations that need to be looked into.

The work that went into the design presentation helped the team straighten out the exact direction we want to head in, and the post-presentation feedback from professor Brumley was also extremely helpful. To incorporate that feedback into something tangible, I’ve been tinkering with Supabase and lovable.ai. Another group brought up that there may be an issue in our selected camera, and I’ve been doing some research into camera resolution, field of view, and how that relates to clarity at a distance.

What’s worrying is I haven’t received an email about our camera being delivered (suitable or not), and although the raspberry pi repository hasn’t been fully fleshed out yet I have a more complete picture of what needs to be done. Next week I should be more free to steam ahead and catch back up.

Posted on

Eric’s Status Report for 2/22/25

This week, I spent a lot of time working on the design review presentation and practicing since I presented on Wednesday. This involved doing research related to the Amber alert use case, specifically for our timing requirements, since we wanted them to be based on the expected situation. I found that the 60 second requirement was sufficient for an average lane change frequency on the highway (2.71 mi) but not enough for the worst case merging scenario (20 seconds), so I made that change to the requirements.    I worked more with the PaddleOCR testing to continue exploring how it performs under more extreme weather conditions. I also worked with Richard to set up the basic pipeline of YOLOv11 to PaddleOCR, where YOLOv11 crops the image down to the plate, and PaddleOCR uses the cropped image to do OCR.

 

My progress is on schedule. Next week, I plan to continue testing the PaddleOCR with the YOLOv11 model integration, and explore methods to increase performance. I plan to use larger datasets to see how the overall pipeline performs, as well as beginning to check the inference time.

 

Posted on

Team’s Status Report for 2/15/25

The most significant risk is that the edge compute solution may not guarantee enough performance (precision and recall) to meet our MVP. The contingency plan is having a two-phase approach where if more accuracy than the edge compute raspberry pi can give us is needed, we then send the image into the cloud, where a more sophisticated model can give us better results.

A change we made to the existing design was that we are now using a Raspberry Pi 4 rather than a 5. This change was made since all the raspberry pi 5s available in storage were claimed very quickly, and since we wanted to test our software as soon as possible on actual hardware, we took a raspberry pi 4 instead. While unfortunate that we’re unable to use the most powerful hardware available, this should not have any impact on our ability to create an MVP or final device since the process for loading the models on these devices are nearly identical. When we run our model, if the performance is in the order of magnitude fitting of a compact processor, we can spend our currently plentiful remaining budget on the more powerful raspberry pi 5.

We have trained the model we will most likely use for our MVP, a YOLOv11n model trained on an open source license plate detection dataset for 400 epochs. It can be found here. We have also looked into existing OCR methods and chosen the PaddleOCR out of them, which we’re currently experimenting with.

Aside from the model, the rpi 4 is currently being developed, with a github repo to be populated by next week. The camera module is also expected to arrive next week as well.

Part A written by Richard Sbaschnig:

A.

Our device aims to improve public safety. This is done by detecting the license plates listed in active amber alerts in a dashcam. Since these alerts are sent to identify suspected kidnappers of children, by increasing the search coverage of amber alerts with our device, law enforcement will be able to find these vehicles sooner and catch kidnappers sooner. This should also have a deterrent effect, since would-be kidnappers would be less inclined knowing that there are these devices all around that can identify their car and notify the police automatically.

Part B written by Tzen-Chuen:

Our device’s social considerations don’t quite appear as an obvious point of concern. The different groups that will be interacting through our device is the manufacturer, the consumer, and the potential child abduction victim. The main point of contention may be between the consumer/end user and the manufacturer, as the manufacturer may install our device without the end user being aware of it, but I believe that this can be mitigated through an explicit opt-in system.

 

Part C written by Eric:

Our license plate recognition system is designed with one of the focuses being affordability, utilizing low-cost Raspberry Pis and camera modules. This provides a more accessible alternative to expensive surveillance systems, ensuring that even communities with limited resources can use our system. This can be especially beneficial for those in rural areas with little existing infrastructure since our device would be mounted as a dash cam, allowing for wider reach and greater impact.

Posted on

Eric’s Status Report for 2/15/25

This week, I focused on researching and testing OCR models for license plate recognition. I experimented with PaddleOCR and EasyOCR, since I saw multiple users saying that TessaractOCR doesn’t perform well. I tested PaddleOCR’s and EasyOCR’s performance on license plates with different orientations and angles. To ensure accurate comparisons, I set up a structured testing workflow and collected sample images from various scenarios. After testing, I found that PaddleOCR consistently outperformed EasyOCR when handling rotated or slanted plates. Based on these results, I decided to move forward with PaddleOCR as the primary OCR engine for the project. I also started looking into ways to eliminate detected text that isn’t from the license plate number.

My progress is on schedule. Next week, I plan to work on integrating PaddleOCR with the YOLOv11 model, and figure out what changes are needed for it to run on the Raspberry Pi. If necessary, I will experiment with different PaddleOCR configurations to further refine accuracy and speed.

The image below shows PaddleOCR’s results on an example plate: