Daria's Brief:

The Duckiebot is a self-driving robot that navigates Duckie Town, a miniature city. It was inspired by self-driving car technology, including lane, light, and color detection. The DuckieBot is made up of a simple plastic chassis, a Pi camera, and a Raspberry Pi computer that processes all the programs that control the bot. To control the robot, the Pi camera records a live video stream, which is then processed by the Raspberry Pi according to pre-written Python programs. 

To detect lanes, the computer uses color recognition to find the center dashed yellow lines, right white lines, and red stop lines. It then uses Canny Edge Detection and the Hough Transform to find the edges of these lines. After combining all of the endpoints of the lines on each side of the lane marker, it finds the best fit lines for both sets of points. To drive from these lines, the Duckiebot tries to match the slope of each line to an ideal, pre-calibrated slope. Based on the difference between the target slop and the actual slope, the Duckie Bot decides if it should continue straight or turn in one direction or the other. 

At intersections, which it recognizes using the red line, it first looks for stop signs. To detect stop signs, it uses a Haar Classifier (a tree-based classifier) to find the stop signs and then filters each potential stop sign to make sure it is in fact red. If it sees either, it obeys the rules of that signal before continuing. Once it is ready to turn, it looks for other red lines in its field of vision to figure out which turns it could make without driving off the turn. It then randomly makes a decision between the possible turns and completes the chosen turn before continuing with the lane following. Overall, the Duckiebot is a complex robot running many layers of programs that allow it to interact with Duckie Town in as many ways as possible. 

Sina's Brief:

A small, car-like robot that can drive autonomously to navigate a miniature town. An onboard Raspberry Pi controls the robot’s two wheels and filters a camera feed to detect key features of the road.  

The Duckie-Bot is a small, car-like robot that can drive autonomously to navigate a miniature town. It is inspired by self-driving cars and the computer vision behind them, including image, light, and color detection. An onboard Raspberry Pi controls the Duckie-Bot’s two wheels and filters a camera feed from the front of the robot to detect key features of the road. There are two main processes that drive the Duckie-Bot:  the filter process, and the motor process. The filter process detects the key features, including road lines, stop lines, traffic lights, and stop signs. Most of these detections are color-based, they look at specific regions of the image that contain the color they are looking for, and then run detections like line or light detection. Then the filter process determines how the things it detects relate to the Duckie-Bot by running them through a series of parameters and seeing if they fit them.  When it finds the road lines, it looks at their slope to determine if the Duckie-Bot is facing the correct direction. When at an intersection, it looks for where it can turn. Then the filter process tells the motor process to power certain motors depending on how the Duckie-Bot relates to what it detected, like turning right at an intersection or turning left to stay oriented with the road lines. A separate motor process is necessary to ensure that the Duckie-Bots wheels can be controlled without causing the filter process to come to a halt. These two processes work together to create a Duckie-Bot which can detect and navigate through all of the features of Duckie-Town.