-
Developed a Unix-like kernel in C, designing core OS components like virtual memory, process scheduling, and a file system. Debugged low-level race conditions and optimized performance, showcasing mastery in systems programming and kernel architecture.
The Weenix Operating System is a modular, Unix-like kernel developed as part of USC's CSCI 420 (Operating Systems) course. This project involved building core kernel components, including:
- Process management
- Threading
- Virtual memory
- File system
All components were built entirely in C and assembly.
## Project Challenges
This project challenged me to:
1. Design and debug intricate low-level systems
2. Ensure seamless integration across various subsystems
3. Apply deep understanding of computer architecture and operating system principles
> Note: Due to academic policies, the actual kernel source code cannot be shared publicly. Please contact me for the code!
View on GitHub
-
This project visualizes cloud heights using ISRO's INSAT 3DR infrared satellite data. By applying a lapse rate model, it calculates cloud altitudes and presents them as a point cloud.
This project utilizes ISRO's INSAT 3DR infrared satellite data to visualize cloud heights. Key features include:
- Application of a lapse rate model for cloud altitude calculation
- Point cloud representation of cloud heights
- Integration of satellite data for accurate visualization
## Technical Highlights
- Data processing of infrared satellite imagery
- Implementation of atmospheric models for height estimation
- 3D visualization techniques for cloud representation
View on GitHub
-
Compares DCT as used in the JPEG standard and DWT as used in the JPEG2000 standard for image compression, including progressive decoding analysis
# DCT DWT Image Compression
This project compares two image compression techniques: DCT (used in JPEG) and DWT (used in JPEG2000). Features include:
- Implementation of DCT and DWT algorithms
- Comparative analysis of compression efficiency
- Progressive decoding simulation and analysis
## Technical Highlights
- In-depth study of transform-based image compression techniques
- Implementation of complex mathematical transforms (DCT and DWT)
- Analysis of compression artifacts and image quality metrics
View on GitHub
-
Developed a DCT-based video compression system leveraging motion vectors for encoding of raw RGB files. Integrated YCrCb color space transformation, audio sync, and advanced compression techniques to achieve optimized storage and playback—delivering smooth, high-quality video with reduced data footprint.
# Multimedia Systems Design Project
## Foreground/Background segmented compression
Developed an innovative approach to video compression by segmenting foreground and background regions using block-based motion detection techniques. Leveraged Discrete Cosine Transform (DCT) to efficiently compress video frames, applying differential compression rates to foreground (high-priority regions with significant motion) and background (static or less critical regions). This method significantly reduced bandwidth usage in video-based communication while maintaining high visual quality for dynamic content. The project demonstrated the practical integration of motion analysis and DCT-based compression in real-time applications like video conferencing and streaming.
The output is shown to have background to be highly quantized whereas the foreground isn't quantized. There's option to play, pause and replay in the custom GUI player.
## Method
- Image frame of size 960 x 540 divided into 16 x 16 macroblocks.
- Uses Three Step Search algorithm to find the motion vectors along X and Y direction, finds magnitude and classifies each macroblock as foreground or background as per the set threshold.
- Macroblocks undergo DCT conversion as per n1 (for foreground) and n2 (for background). For best results use n1 = 0 and n2 = 7.
- Audio is synced with the video playback using time.time()
## Requirements
To run the code, you need the following dependencies installed:
- Python 3.x
- OpenCV (`cv2`)
- NumPy
- Matplotlib
- os
- time
- threading
- wave
- pyaudio
- tkinter
- PIL
## Usage
```bash
python video_encoder.py <.rgb> n1 n2
```
```bash
python video_decoder.py <.cmp> <.wav>
```
View on GitHub
-
Flappy Bird using the NEAT (NeuroEvolution of Augmenting Topologies) algorithm.
=This project implements an AI for the Flappy Bird game using the NEAT algorithm. Key aspects include:
- Implementation of the NEAT algorithm for neural network evolution
- Integration with the Flappy Bird game environment
- Training and optimization of AI performance
## Project Insights
- Exploration of evolutionary algorithms in game AI
- Balancing between exploration and exploitation in AI learning
- Performance analysis and optimization of the AI agent
View on GitHub
-
Making a network from scratch using Python!
This project involves building a neural network from the ground up using Python. Key components include:
- Implementation of forward and backward propagation
- Customizable network architecture
- Various activation functions and loss calculations
## Learning Outcomes
- Deep understanding of neural network fundamentals
- Hands-on experience with gradient descent and backpropagation
- Insights into optimization techniques for neural networks
View on GitHub
-
The Sparky Game Engine is a custom 2D game engine developed using C++ and OpenGL from scratch. It makes use of GLSL (OpenGL Shading Language) for shader management.
A custom 2D game engine built from scratch using C++ and OpenGL. Features include:
- Core engine architecture
- Rendering system using OpenGL
- GLSL shader management
- Basic physics and collision detection
## Technical Challenges
- Efficient memory management and performance optimization
- Implementation of a flexible entity-component system
- Integration of various subsystems (graphics, audio, input)
View on GitHub
-
Tookivi game engine is a project built upon a fork of the Hazel engine. The primary feature is a Python script that performs real-time super-resolution upscaling of the game's output resolution.
# Super Resolution Game Engine
The Tookivi game engine, based on the Hazel engine, features real-time super-resolution upscaling. Key aspects include:
- Integration of super-resolution algorithms with game rendering
- Python script for real-time image processing
- Enhancement of visual quality in game output
## Innovation Highlights
- Real-time application of machine learning for graphics enhancement
- Optimization of super-resolution algorithms for gaming performance
- Bridging game engine technology with advanced image processing techniques
View on GitHub
-
Implements various resampling techniques to convert images by either upsampling or downsampling
# Image Resampler
This project focuses on implementing various image resampling techniques. Features include:
- Upsampling and downsampling algorithms
- Multiple interpolation methods (e.g., nearest neighbor, bilinear, bicubic)
- Comparative analysis of different resampling techniques
## Technical Aspects
- Implementation of complex mathematical algorithms for image processing
- Optimization for efficient processing of large images
- Analysis of image quality and performance trade-offs in resampling
View on GitHub
-
Segments image pixels based on hue thresholds in the HSV color space
# Color Space Segmentation
This project focuses on image segmentation using HSV color space. Key features:
- Implementation of HSV color space conversion
- Hue-based thresholding for pixel segmentation
- Visualization of segmented image regions
## Project Insights
- Understanding of color spaces and their applications in image processing
- Exploration of threshold-based segmentation techniques
- Analysis of segmentation effectiveness in various image types
View on GitHub