## Inspiration

Traffic congestion is already the most painful part of city life, and it's only going to worsen as cities grow. We need clever solutions, and those solutions need data. But that data is sorely lacking: even today, traffic counting is often done by hand, making it prohibitively expensive to deploy on a large scale.

Thankfully, machine vision has improved by leaps and bounds in the last couple of years, meaning that the problem can now be solved in 24 hours by four college students in a basement.

## GoWithTheFlow

GoWithTheFlow is an open source app that enables any group with a simple camera to quickly and easily analyze the flow of objects in the camera frame. The user inputs a video, and the software counts the number of objects of interest moving between different exit and entry points within the frame. The user can also manually select intersections for additional information.

While this project was initially created to monitor traffic flow and eliminate the need for manual traffic counting, due to the versatile nature of the machine learning algorithms, we were able to modify the detection scheme so that it is able to detect any kind of object moving in the camera's view. This means that this simple piece of software can be used to monitor the movement of people, cars, animals, basically anything that might stand out as "of interest" in an environment.

## Applications

While flow and movement analysis is hugely important in countless areas of society, one of the most immediate applications of this software is when it comes to hosting events. The hosts may want to know what areas of the venue get the most attention, how the crowd develops, or even just how to best guide people as they move about when planning for an event, and this app can be a great asset in doing just that.

It could also be a great asset in monitoring the movement of herds of groups of animals for ecological reasons. While it may be very difficult to manually comb through countless hours of footage to try and make sense of the large-scale movements of animals, our system provides a simple accessible way to do much of this analysis automatically.

While we could go on, suffice it to say that we have a created a generalizable way to monitor and analyze the movement patterns of almost any macroscopic system using just a camera.

## How we built it

The user interface was written using PyQt5. The input video is split into frames, then each frame is fed into the YOLO-9000 image classifier. The large size of this classifier is what ultimately allows our project to work as a generalizable flow monitoring system. The classifier returns the positions of interesting objects in each frame. This data is then linked and analyzed using an unsupervised machine learning algorithm to determine the probable location of entrance/exit points. The data is then analyzed and the flow rates in and out of each entrance and exit are provided. The user can also manually adjust the exit/entrance locations, and see what the probable flow rates and patterns would be for their setup. We used an AWS 2.2xlarge instance to run the majority of our video analysis for two main reasons: one, the GPU support enabled us to process large videos very quickly for testing purposes and two, it was a community instance that already had the majority the software required for our project already installed. The image overlays are drawn using OpenCV.
## Inspiration

We got lost so many times inside MIT... And no one could help us :( No Google Maps, no Apple Maps, NO ONE. Since now, we always dreamed about the idea of a more precise navigation platform working inside buildings. And here it is. But that's not all: as traffic GPS usually do, we also want to avoid the big crowds that sometimes stand in corridors.

## What it does

Using just the pdf of the floor plans, it builds a digital map and creates the data structures needed to find the shortest path between two points, considering walls, stairs and even elevators. Moreover, using fictional crowd data, it avoids big crowds so that it is safer and faster to walk inside buildings.

## How we built it

Using k-means, we created nodes and clustered them using the elbow diminishing returns optimization. We obtained the hallways centers combining scikit-learn and filtering them applying k-means. Finally, we created the edges between nodes, simulated crowd hotspots and calculated the shortest path accordingly. Each wifi hotspot takes into account the number of devices connected to the internet to estimate the number of nearby people. This information allows us to weight some paths and penalize those with large nearby crowds.
A path can be searched on a website powered by Flask, where the corresponding result is shown.

## Challenges we ran into

At first, we didn't know which was the best approach to convert a pdf map to useful data.
The maps we worked with are taken from the MIT intranet and we are not allowed to share them, so our web app cannot be published as it uses those maps...
Furthermore, we had limited experience with Machine Learning and Computer Vision algorithms.

## Accomplishments that we're proud of

We're proud of having developed a useful application that can be employed by many people and can be extended automatically to any building thanks to our map recognition algorithms. Also, using real data from sensors (wifi hotspots or any other similar devices) to detect crowds and penalize nearby paths.

## What we learned

We learned more about Python, Flask, Computer Vision algorithms and Machine Learning. Also about frienship :)

## What's next for SmartPaths

The next steps would be honing the Machine Learning part and using real data from sensors.
## Inspiration

Civic authorities are constantly working to improve transport for their cities. Their efforts, however, often lack an important piece: access to accurate data about how current transport systems are used. A better understanding of how people commute, share rides, and take public transport today will inform how these systems can be better tomorrow.

## What it does

In essence, Argonaut is a marketplace: it helps users part with any personal data that they're willing to share, in return for monetary incentives in the form of Algorand coins (Algos). Authorities can buy data packs - which are anonymised and aggregated clusters of such data submitted by multiple users, for a price, which is then distributed amongst each of the contributors equally. Here's the key: the blockchain keeps a track record of what organisation is requesting and accessing what data, even while maintaining complete anonymity on the part of the sellers.

## How I built it

We used React.js to build the frontend, a Node.js/Express powered backend; Python to scrape through personal data dumps accessed via Google Takeout, and the Algorand JavaScript SDK to implement the blockchain-based transaction management system.

## Challenges I ran into

The principal challenge we faced was how to implement Blockchain for managing access to personal data. Another important challenge was to do with making sure that the anonymity of users sharing their data is maintained, whilst also keeping any shared data private.

## Accomplishments that I'm proud of

This was our first deep dive into Blockchain technology, and we were glad to be able to use Algorand's APIs and Dev Tools to be able to build a platform aimed at enhancing urban decision making, while simultaneously helping people like you and us take back control of their personal data.

## What I learned

We learned about the power of the blockchain, and how decentralised ledgers have applications far and beyond the traditional financial markets that we've currently seen them in.

## What's next for Argonaut

Argonaut can be scaled up to include the ability for users to connect Google Maps/Uber/Lyft and a lot of other apps directly to the platform so that their periodic data dumps can be seamlessly and automatically streamed into the platform, versus the current requirement of having to upload personal data dumps.