Nidhi Uppoor

Pathfinding Visualizer

2023-11-11T18:59:00+00:00

Visualization of popular pathfinding algorithms

To review the code files of this project, check out its GitHub repository at Pathfinding Visualizer on GitHub.

Introduction:

In computer science and game development, pathfinding algorithms play a pivotal role in finding the shortest or most optimal paths to get from one point to another. In this project, I explore and visualize the working of pathfinding algorithms - specifically Breadth-First Search (BFS), Dijkstra’s and A*.

Development Tools

I developed this project in Visual Studio using C++ and SFML (Simple and Fast Multimedia Library) - a graphics library that facilitates the creation of interactive applications.

Algorithms

The algorithms implemented in this project are -

Breadth-First Search (BFS): A fundamental
algorithm in graph theory, explores all the vertices at the current depth before moving on to the next depth level.
Dijkstra’s Algorithm: An informed algorithm, makes decisions based on the accumulated cost to reach each node and finds the path with the minimum total cost.
A* Algorithm: Introduces heuristics to improve efficiency. It aims to find the shortest path but uses an estimation of the remaining distance from the current node to the goal.

Working

The code creates a grid and randomly assigns some of the cells as walls to create obstacles for the pathfinding algorithms. The Generate Map button can be used to genenate new random walls.

We can then select the algorithm to be run and view the cells that the algorithm visited as well as the path it chose to reach the end point. The total length of the paths i.e. the number of cells a path is made up of and the times taken by the algorithms are outputted.

Your browser does not support the video tag.

Conclusion

In conclusion, this C++ and SFML project effectively visualizes and compares pathfinding algorithms. It provides intuitive insights into their exploration strategies and decision making processes. In certain scenarios, such as this one with an undirected graph with equal edge weights, BFS and Dijkstra’s may outperform A* due to the absence of a meaningful heuristic to guide the search. This underscores the importance of algorithm selection based on the characteristics of the problem.

Technical Analysis of ‘Tea for God’

2023-11-11T18:59:00+00:00

A VR Paradigm Shift

Introduction and Impossible Spaces

“Tea for God” is a game that introduces innovative technical elements to enhance user experience, and has caused a subtle yet noticeable shift in the virtual reality (VR) gaming landscape. This analysis seeks to provide a nuanced exploration of the technical complexities of the game’s distinct approach to VR immersion.

“Tea for God,” by indie developer Jarosław Ciupiński, was released in full on July 19th, 2023, but had been in development and available as a demo since 2019. This game uses the design principle of impossible spaces, a method that creates the illusion of multiple spatial volumes existing concurrently, despite the fact that such coexistence is impossible due to their overlapping nature. This concept challenges traditional notions of spatial design by seamlessly blending areas that would occupy the same space in the physical world but are perceptually separate in the virtual realm. This intricacy creates an immersive and dynamic environment that transcends physical limitations.

Procedural Generation

Paired with the procedural generation of the game environment, the impossible spaces technique allows users to navigate virtual worlds while remaining within the confines of their physical environment. In this game, procedural generation, a dynamic process of content creation, tailors the in-game environment based on the physical space available in the user’s room or play area. The game ensures that the user has a seamless and immersive journey without the worry of colliding with physical obstacles by adapting to the real-world surroundings. This synergy of impossible spaces and procedural generation not only showcases the technical prowess and operational efficiency of the game but also enhances the user’s sense of agency within the virtual universe.

Natural Locomotion System and User Experience

Furthermore, the incorporation of impossible spaces allows the game to commit to natural locomotion. Unlike conventional VR experiences, which may rely on teleportation or sliding movement mechanisms, the interconnected impossible spaces create a vast virtual landscape that users can navigate by walking naturally within their physical boundaries. This approach to in-game movement adds realism to the gameplay and facilitates an intuitive and user-friendly experience. The game caters to diverse player preferences, allowing users to tailor their experiences by adjusting difficulty levels, disabling characters, or switching between modes. This means that the player can go for a peaceful walk in the virtual world, shoot enemies in the simpler action-oriented arcade mode, or explore the game’s full depth in the roguelite mode.

Conclusion

Looking ahead, the technical ingenuity of this game and the overwhelmingly positive response from its audience indicate a shift in how we experience VR gaming. The ability to traverse intricately crafted spaces as naturally as possible within the confines of the physical environment provides a more profound understanding of spatial interaction. “Tea for God” serves as both a benchmark and a precursor as we navigate the ever-changing landscape of immersive technology, laying the groundwork for exciting possibilities in the realm of virtual reality.

Space Shooter

2023-11-11T18:59:00+00:00

Dodge asteroids, defeat foes, and dance with missiles in this cosmic space escapade!

To review the code files of this project, check out its GitHub repository at Space Shooter on GitHub.

Introduction

Embark on a fun cosmic journey with my first SFML game project – a space shooter. Brace yourself for a classic gaming experience where you’ll navigate through asteroid fields, engage in battles with enemy spaceships, and skillfully evade relentless missiles.

Development Tools

I developed this project in Visual Studio using C++ and SFML (Simple and Fast Multimedia Library) - a graphics library that facilitates the creation of interactive applications.

Gameplay

In this 2D top-down game, the player controls a spaceship using wasd or arrow keys for movement. The player can shoot bullets by clicking the left mouse button.

Asteroids rain from the top of the screen moving towards the bottom with varying speeds and having different sizes and consecutive damage dealt to player on collision. The player must dodge or destroy these asteroids.

Enemy spaceships enter from the top of the screen and spawn missiles aimed at the player every few seconds until they are destroyed by the player. The missiles track the player and need to be shot down to avoid damage.

There is a health bar and a point counter at the top of the screen.

Health packs move in the same way as the asteroids but are much rarer and restore some of the player’s health when caught. Shooting a health pack however destroys it with no health restoration, discouraging the player from continuously shooting without aiming.

The diagram below summarizes the gameplay and shows the entities involved in the game -

Game Demo

Your browser does not support the video tag.

Conclusion

Looking ahead, there’s a lot I’m eager to do with this game. In the short term, I plan on adding animations, like flames from the spaceship engine and explosions for when entities collide. I also plan to add game music and sound effects to make the game more immersive and enjoyable. There’s still plenty to learn and improve, but I’m excited for the next steps. In addition, I believe this project sets the stage for future adventures! The road ahead promises more creativity, more challenges, and undoubtedly, more fun.

Voronoi Diagrams

2022-05-05T18:59:00+00:00

Mathematical Review, Fortune’s Algorithm and GUI Implementation

Introduction

A Voronoi Diagram has a vast list of applications in fields ranging from archeology and astronomy to robotics and zoology. It can also be used to solve various problems in computer science such as toxic waste dump problem (largest empty circle problem), K-nearest neighbours problem, Knuth’s post office problem and many more.

Fortune’s algorithm was one of the first ways implemented to solve a Voronoi and introduces the important concept of sweep line algorithms.

So, let’s understand both of these better with a series of blog posts and a simple GUI implementation. We first understand and visualize the concept of Voronoi diagram for a set of points on a 2-dimensional plane geometrically in terms of mathematical statements as this gives us important properties of the Voronoi diagram. Then, we look at Fortune’s algorithm and understand its working and relevance.

A Mathematical Review

To read the full blog on this topic, visit Mathematical Review of Voronoi Diagrams on Medium

Presented as a blog on Medium, this module details all the mathematical concepts required to compute a Voronoi diagram and discusses some of its properties.

A Voronoi diagram divides a given plane in regions or cells with respect to the set of points such that for each point in the diagram, the corresponding region consists of points closer to it than to any other point. The concepts of Voronoi edges and points is discussed in the blog and we see that the diagram can be viewed as a connected planar graph excluding the edges that extend to infinity. We then apply Euler’s formula for planar graphs and the handshaking lemma in order to derive the geometrical complexities of a Voronoi diagram. The problem regarding edges extending to infinity is addressed by considering an additional point that all these edges connect to.

Fortune’s Algorithm

To read the full blog on this topic, visit Fortune’s Algorithm on Medium

Presented as a blog on Medium, this module explains the algorithm given by Steven Fortune for computing the Voronoi diagram using a sweep line approach.

In the blog, we take a look at its complexity as compared to other algorithms and explore a step-by-step explanation of how this algorithm is applied on a set of points on a plane. We describe parabolic arcs for each point and see how they merge to form Voronoi edges and a Voronoi vertex is defined in terms of these arcs. We also take a look at the beach line data structure in use which is a balanced binary tree.

A GUI Implementation

To review the code for this GUI implementation, check out Voronoi Diagrams GUI Implementation on GitHub

This module consists of a Python GUI made using Tkinter which presents a canvas to the user. On this canvas, the user double-clicks their left mouse button to plot points. The calculate button can then be used to compute a Voronoi diagram for the points using the scipy.spatial.Voronoi module which is an inbuilt function in the scipy package. We plot this diagram.

We can choose the continue button to unlock the canvas and add more points to the existing set of points and see how the Voronoi diagram is affected.

The clear button clears and unlocks the canvas so that we may start anew. The Toxic Dump button allows us to visualize the solution to the toxic waste dump problem (also known as largest empty circle problem) wherein we try to find a circle within our diagram such that it has the largest diameter while also having no points within it. We see that the center of this circle lies on a Voronoi vertex.

The user also has the choice to generate a random set of points by giving the number of vertices to be drawn and the program then generates a Voronoi diagram for those points.

Interactive Language Learning

2022-05-05T18:59:00+00:00

An exploration of immersive learning using VR and NLP

To read the full paper, kindly visit Paper on IEEE Xplore or Paper on ResearchGate

Introduction

During the final year of my undergraduate degree, I authored this paper titled “Interactive Language Learning with VR and NLP Assistance” along with my teammates under the guidance of our research mentor. The paper was presented in the 2022 IEEE 7th International conference for Convergence in Technology (I2CT) which was a 3 day conference - from the 7th to the 9th of April 2022.

This experience was invaluable to me and has taught me a lot. During the ideation phase of the process, we conducted a market survey to gain a better understanding of how people in our community approach online learning and their opinions of it - especially considering that Covid had made online learning a necessary part of everyone’s life. Though we received varied responses, the general consensus remained that online learning wasn’t as engaging as in-person learning. To find a solution to this problem we began our research and narrowed down our topic to language learning and how Virtual Reality (VR) and Natural Language Processing (NLP) could provide a solution.

Abstract

In the past years, society has evolved exponentially in terms of technology and so has people’s need for growth and learning. Education has encountered a structural redefinition. As companies and governments open up to a hybrid economic and work model, it can be assumed that teaching/learning increasingly rely on a combination of personal and digital learning spaces. Due to the importance of languages from an individual perspective as well as from business and cultural perspectives, it is imperative that language learning also be incorporated into these virtual spaces. Research has proven that immersion is the best method of learning a language. This paper explores the use of virtual reality to provide a more engaging and rewarding experience. VR boasts a number of features that are useful for education: it displays environments in 3D, offers interactivity and even presents the user with audio, visual and haptic feedback. As opposed to videos and other passive learning methods, VR allows for direct interaction with the environment.This learning system can further be complemented with the help of natural language processing (NLP) to broaden the scope of interactions and improve engagement. And these topics have been explored in detail in this review paper.

Prototype Demo

During the course of our research, we developed a prototype application. In the development of this prototype, I used Unity and C# scripting to create interactions and used Python.NET so my C# scripts could interact with the Python code developed by my teammates. In this demo, the user wakes up in their VR bedroom, first chooses to learn using fill-in-the-blank style MCQ conversations and then practices conversations with the chatbot. Both the learn and practice module use the scenario of ordering food at a restaurant as an example.

Your browser does not support the video tag.

CycleGAN Style Transfer

2022-03-03T18:59:00+00:00

Unpaired Image-to-Image Style Transfer using CycleGAN

To review the code for this project, visit CycleGAN Style Transfer on GitHub

Introduction

Image-to-image translation is a problem where the goal is to learn the mapping between an input image and an output image using a training set of aligned image pairs. However, the requirement for paired training data is a major limitation as this data can be challenging and expensive to prepare. To overcome this limitation, we look into the use of CycleGAN which can perform image-to-image translation using unpaired data.

Model Architecture

This approach uses the generative adversarial network (GAN) architecture which is comprised of two models: a generator model and a discriminator model. The generator takes a point from a latent space as input and generates new plausible images from the domain, and the discriminator takes an image as input and predicts whether it is real (from the dataset) or fake (generated).Both models are trained in a game, such that the generator is updated to better fool the discriminator and the discriminator is updated to better detect generated images.
CycleGAN is an extension of the GAN architecture that involves the simultaneous training of two generator models and two discriminator models. One generator takes images from the first domain as input and outputs images for the second domain, and the other generator takes images from the second domain as input and generates images for the first domain. Discriminator models are then used to determine how plausible the generated images are and update the generator models accordingly.

Losses Used

In CycleGAN, as there is no paired data to train on, there is no guarantee that the input x and target y pair are meaningful during training. In order to enforce that the network learns the correct mapping, cycle consistency loss is used.
In cycle consistency loss, • Image X is passed via generator G that yields generated image Y^. • Generated image Y^ is passed via generator F that yields cycled image X^. • Mean absolute error is calculated between X and X^.
In total, we calculate three types of losses - cycle losses, adverserial losses i.e. generator loss and discriminator loss, and an identity loss.

Output

In this project, I used CycleGAN to perform style transfer between photos and Studio Ghibli style art. The results of this model can only be judged qualitatively so here are a few sample outputs.

Photos to Ghibli-style art:

Ghibli to realistic:

Real-Time Driver Drowsiness Detection

2021-04-03T18:59:00+00:00

Using Convolutional Neural Networks

To review the code for this project, visit Real Time Driver Drowsiness Detection on GitHub

Introduction

One of the most prevailing problems across the globe today is the booming number of road accidents. Driver’s drowsiness or lack of concentration is considered as a dominant reason for such mishaps. This project therefore proposes an approach to implement a driver drowsiness alert system which would calculate the driver’s sleepiness and prevent such accidents caused by the same.

By capturing visual information about the driver and using this behavioral data with AI, we have developed a real-time drowsiness detection system based on Convolutional Neural Networks (CNNs). Here, we create a classification network to determine if the driver’s eyes are closed and whether the driver is yawning. The system captures the driver’s images and examines eye and mouth positions and uses this data and our CNN model to detect fatigue. Continuously monitoring the driver’s state, as soon as the driver indicates drowsiness, the system sounds an alarm to alert the driver.

Data Flow and Process Descriptions

Pertinent Processes:

1) Collect input: It takes in video feed from the user’s device and breaks it down to frames for further processing.

2) Convert to Grayscale: Convert each individual video frame to grayscale.

3) Resize Image: Resize the image to a uniform dimension.

4) Face and Eye Detection: From the processed image, detect face and eye in the given frame.

5) Crop image: After facial parts crucial to the algorithm have been detected, we crop the rest out.

6) Detecting Drowsiness: We feed these optimally cropped images to our detection models to detect drowsiness levels.

7) Train Eye and Yawn Classifier Model: Train the model to classify yawn from no_yawn and eye open or close.

8) Determine Drowsiness Level against Threshold: After detecting the drowsiness level of the user, the system compares it to the decided threshold value.

9) Alarm Ringer: If the drowsiness level crosses the decided threshold, the drowsiness has reached a critical value and the system rings out an alarm to alert the driver.

Conclusion

Thus, this real-time system utilizes a webcam to capture images continuously and meaure the state of the driver according the to specified algorithm and give a warning when required. The user must have access to a device with a working camera and must grant the application the permission to access the same.