Sagar Patil

The marching cubes algorithm is used to generate a 3D surface out of a scalar field. As a side project, I wanted to implement the Marching Cubes algorithm efficiently in the Unity3D game engine to generate interactive, procedural terrain.

The first method I tried was to write the algorithm in a compute shader. However, this proved to be too slow due to time it took to move the vertices from the GPU back to the CPU.

After that, I tried to implement the algorithm in Unity's Job system, which allowed for automatically parallelized tasks. This offered a significant speed benefit.

In order to make the terrain editable, I also added a chunking system, so that the terrain could be split into chunks and only one chunk had to be regenerated when the underlying voxel data changed.

The code for this project can be found on GitHub.

Over the summer, I wanted to build and test custom solid rocket motors, so I built a test stand to measure the thrust of motors.

To achieve this, I used a load cell along with an ESP 8266 microcontroller, to read the load cell and transmit the data.

All the code that runs on the ESP was written in C++ using the Arduino ecosystem.

The program on the ESP was responsible for reading the data from the load cell, storing the data in SPIFFS, sending data over TCP to connected clients, and broadcasting mDNS.

An electron app was created to recieve and visualize the data. The electron app used mDNS to find the IP address of the ESP, and then recieved data on a TCP socket. It uses uPlot to graph the data in real time, and also records the data.

Finally, it includes an interface to perform various functions on the ESP, such as starting/stopping data collection, downloading onboard data, and calibrating the load cell.

All the code for this project can be found on GitHub.

For the HackJPS hackathon, my friends and I decided to create a chrome extension that could summarize articles. However, we didn't want this extension to be like the usual summarizer which just extracts sentences that are already in the article.

In order to achieve this, we decided to use a natural language transformer model to perform the summarization.

First, we needed to extract text from any article, so we used a library called mercury-parser. On the backend side, we used Python with Flask. For the summarization model itself, we used a version of BART finetuned on the CNN/DailyMail dataset.

We also attempted to quantize the model using ONNX in order to run it on users' machines, but that wasn't possible within the scope of the Hackathon. Regardless, we were able to win the hackathon. We completed the entire project, start to finish, in the span of just a few hours, which we thought was fairly impressive.

More information about the project can be found on DevPost and the code can be found on GitHub.

Hawkvision is a computer vision project I developed during my time at the FIRST Robotics Team 2554.

The goal of the project was to track a target marked with retroreflective tape. The camera that we used on the robot had a green ring light on it, so that the vision target appears bright green on the camera view.

To track the targets, we used a program called GRIP to build an OpenCV pipeline with color thresholds that narrowed out the vision target. We also calibarted the camera and found its focal length to determine the angle to the target.

With this information, we were able to run a PID loop on the robot so that it could automatically align with the target on command.

The code for this project can be found on GitLab.