johnpl-io / smart_park Goto Github PK

Python 36.58% JavaScript 42.61% HTML 1.38% CSS 12.36% Dockerfile 1.06% Shell 0.10% TypeScript 5.92%

smart_park's Introduction

Welcome To Smart Park!

For our final project, we have developed Smart Park, an app designed to simplify the often frustrating task of finding nearby available parking spots. Urban parking can be a nightmare, but with our app, users can skip the stress of endlessly circling for a spot. Instead, Smart Park recommends parking locations based on proximity and availability. What sets Smart Park apart from other parking apps is its adaptive learning feature. When initially deployed, the app doesn't rely on preexisting map data. Instead, it learns from user behavior, noting where users successfully parked as potential spots it can recommend to other users in the future. As a result of this, our app is adaptable to virtually any location worldwide and can be used to find free parking. Our tech stack uses PostgreSQL with PostGIS for database, Python and flask for our ORM and API, and react.js for our frontend.

Video Demo

In this video a demonstration of the is a close free spot is found while cars are being simulated parking and leaving.

databases.mov

Instructions on Running Project

From the terminal run docker compose up in the smart_park directory
cd into the Backend/src install proper requirements and run the populate.py
Then in the Backend/src directory run the app.py file
Download images of cars from https://drive.google.com/drive/folders/1semOhx2VbV_6dMk1OklQsQdu-raN2LHL?usp=sharing and put the images folder as Frontend/public/images
Install nyc_streets from https://postgis.net/workshops/postgis-intro/about_data into a new database called under smart_park_db/nyc. This can be done using QGIS with this method https://www.youtube.com/watch?v=fROzLrjNDrs.
Go to the Frontend directory run npm install and then npm start
Make sure GMAP_API_KEY='API_KEY' in your environement variables.
Finally go to the ProxyServer folder and run node gmap.js

Port References

The flask service layer runs on port 5000
Frontend runs on port 3000
Proxy server runs on port 2000 (it checks to see if the user is on a street when they click the park button)
Database is in port 5432, username is user, password is password, and database is called smart_park_db

smart_park's People

Contributors

Watchers

smart_park's Issues

Updating Database When User Leaves Parking Space

When a user leaves a parking space, we need to query the spots table for any available regions that are sufficiently close to the now freed-up space. These regions would then be merged with the freed-up parking space.

add database of cars

add scraped database of cars to the cars table

add some sort of simulator

add simulator through random points or movement in a region etc

Car Registration Page

This page would allow the user to select and register a car that they own.

Updating Database When User Parks

When the user parks, we first need to create a new parking region in our database that approximates the region that the user's car takes up. To do this, we can approximate the user's car to be in the shape of a rectangle and take their location to be the top left coordinate. Then we can use the dimensions of the user's car to find the other 3 coordinates.

After that, we need to check if our new parking space overlaps with any of the other regions in our spots table. We should always get only one region from this.

If we subtract off the parked space from the region that contains it which should give us two regions.

If one or both of the regions are sufficiently small then that means that the user either parked right at the edge of the parking edge like at the end of a street or right between two cars so we can merge those hanging regions with the parked space if that happens.

If after this, we still have two regions, then we update the region for the corresponding spot entry and make a new spot entry for the other available region. And if we just have one region, then we just update the corresponding spot entry.

Check if a Parking Space is Available

As the user is searching for a parking space, we would need to repeatedly poll the backend to check if the recommended parking spaces are still available.

Finding Most Preferred Parking Space

Given a user’s location and parking history, find the parking spaces that the user is most likely to prefer. The metric used to score the parking spaces should take into account at least the following factors:

The distance between the user and the parking space
The distance between the parking space and the closest frequent area that the user tends to park often in

The endpoint should take in how many parking spaces to return as a parameter.

If, as the user is searching for a parking space, one of the parking spaces becomes occupied then from the frontend we would use this endpoint to find the next most preferred available space and replace the occupied spot with the new one.

Putting Constraints On Region

It might be good to add constraints on the regions in our database to make sure we don't make any mistakes like make an invalid polygon or make a region whose area is too small. This website gives some pretty good constraints: https://www.crunchydata.com/blog/spatial-constraints-with-postgis-part-1

Creating a List of Parking Spaces For Frontend

For the demo, we might need to indicate what regions the user can park in by creating a box around them. The backend wouldn't have access to this list. It would learn the map as users park. If a spot is occupied, we might need to make it known only when the user tries to park in there and then give an error message saying that the space is currently occupied.

Look into map ui

Open street map box etc

Extracting Patterns from User's Parking History

Given a user’s parking history, we need to be able to extract parking habits and patterns by finding frequent areas that the user tends to park in. This would be used as a factor to determine the desirability of a parking space so it would need to be efficient. One way we could do this is by going through all of the available parking spaces and finding how many times the user had parked within some radius of the available parking space in the past.