Hi, I'm Edward!
student | developer | rustacean
Automated specific data visualization processes (such as 3D colored lag plots) that convert raw data to human-interpretable data
- Used Python and associated data science libraries, including pandas, numpy, matplotlib, and plotly to process time-series data
- Worked with both pre-processed and raw foster-care data, on the scale of millions of entries.
- Introduced to and implemented data analysis concepts and methods: 3D lag plots, lowess smoothing, differencing, aggregation, etc.
- Introduced to concepts of attractors, autocorrelation, convergent cross mapping, etc.
- Python
Uses the Fourier Transform to create animated traced approximations of images.
- Take an input image and create contours out of it
- Find a way to connect contours (as they are not necessarily closed) into one closed path
- Apply the DFT and Inverse DFT to find the fourier coefficients of the path
- Use the approximated coefficients to recreate animations of the approximate path being drawn
- Initially prototyped in MATLAB, then moved to python for animation speed (bottleneck was drawing, not calculation)
- Generate text parametric equations of approximated paths
- MATLAB
- Python
Gets user-inputted mood and heartbeat and displays them on paired devices in a smooth, aesthetic format. Helpful for long distance relationships!
- Rust server to allow for cleaned up realtime communication between clients over UDP with a custom protocol
- Uses both the BLE and wifi client capabilities on the ESP32 to allow for user configuration and communication between devices
- Custom 3D printed parts and wiring
- Used parts such as WS2812B LEDs, electrolytic capacitors, resistors, 18650 batteries, and capacitive touch sensors
- Designed, assembled, soldered, and implemented from scratch
- Android configuration apps to allow for custom lighting and settings on each client device
Check the blog for updates and more details :)
- Arduino
- Rust
- Java
- Kotlin
- Android
Built and maintained the main code repository for FTC team #3216, used in both the 2017-2018 and 2018-2019 competition seasons.
- Field-centric localization with Vuforia
- Robust game element detection using TensorFlow Lite
- Wrote and manually tuned PID control systems for motion
- Overall intended to be highly modular in structure (Composition > Inheritance for robot parts) and extensible
- Asynchronous Command system where specific actions are separated into their own Command sub-class
- All hardware and software components separated into their own Component sub-class
- Java
- Kotlin
- Android
Implementation of a classification neural network from scratch over the summer of 2017.
- 97% accuracy on the MNIST dataset
- Stochastic gradient descent learning
- Based on neuralnetworksanddeeplearning.com
- Rust
A proof-of-concept to detect FTC Rover Ruckus game elements using OpenCV.
- Currently using colorspace thresholding to detect objects, augmented with watershed for segmentation of objects
- Potential usage of cascade classifier
- Intend for depth calculation capability in order to get 3D relative coordinates of objects purely based off of image
- Python
- OpenCV
This site! Modern and clean, building on flexdinesh/dev-landing-page as a starting point.
- Site itself is pure HTML5/CSS, minimal JS used
- Custom static site generation from templates using Python and Jinja2
- CSS
- HTML
- Python
A graphical gravity simulation with a modal UI, written in Rust and using GTK.
- Simulate gravity for bodies
- Path drawing
- Good editing UI (switch to edit mode, then click for center, then click for outer point, click for direction vector, etc.)
- Horizontal/Vertical zooming and graph drawing
- Good performance
- Rust
An attempt at replicating a very basic version of dan-ball's infamous powder game in MATLAB.
- Final project for CEE 101S, featuring near-real-time graphics in MATLAB.
- Displayed the feasibility of vectorizing large amounts of chained conditionals to allow for speed comparable to compiled programs with for loops (for loops are notoriously slow in MATLAB).
- MATLAB
A lisp dialect with an interpreter written in Rust from scratch.
- Supported a couple of basic mathematical operators, print, etc.
- All of the necessary framework to make a useable language was in place
- Rust
A GTK-based desktop bar-style audio visualizer, designed to run smoother and faster than Impulse (a similar program running on the Screenlets framework) while taking less system resources.
- Visibly smoother than Impulse and ~half (4% vs 8%) the total cpu usage of Impulse
- Parallel design to allow for multiple graphical instances to run at the same time even on the same audio sinks
- Rust
Based off of the popular Lixie Clock, but PCBs, lasercutting designs and programming done completely from scratch. WIP (Project materials are stuck in Princeton)
- Arduino
Hacked and reprogrammed multiple pre-existing hardware devices while adding smart functionality and integration into personal home assistant server to some by the creation of custom PCBs.
- Setup a personal home assistant instance with esphome on an old PC, running as a docker image on a Fedora Linux distribution
- Integrate a personal plex media server over a zfs raid-type array with otherwise unused hard disks, with a small SSD cache, giving fault redundancy and speed (saturates router)
- Design, assemble, and program custom PCBs for temperature sensors and lamps that do not have existing smart functionality on the market
- Reverse engineer multiple lamp-type and controller pcbs in order to reprogram them to work with the esphome/home assistant system
- Create a full motorized blind controller with PID position control for optimal speed and to prevent overshooting
- Linux
- Arduino
- PCB Design
A reimplementation of the core features of the original Portal games (with some custom levels too).
- Led a team of 2 to build a Portal-like game over 2 months, winning the technical, best choice awards out of 26+ projects.
- Achieved both MVP goals of implementing core features and stretch goals of building our own levels and having a fully working game.
- Implemented real-time recursive portal rendering using stencil buffers, direct UV mapping, and custom shaders.
- Created custom physics interface allowing for portal placement, teleportation and interaction using Cannon.JS.
- Optimized asset loading pipeline to bypass Three.JS limits, achieving less than 100MB memory usage, zero level load time.
- Wrote a full writeup located at the repository detailing the implementation and design choices and the evolution of the project.
Try the online demo here and the writeup here!
- JS
- GLSL
- Graphics
A photorealistic raytracer rendering at real-time frame rates.
- Worked closely with a partner to build a raytracer capable of handling multiple geometric primitives and materials.
- Implemented lighting effects including hard shadows, soft shadows, and transmissivity for enhanced realism.
- Written in GLSL to achieve real-time frame rates in the browser.
- JS
- GLSL
- Graphics
