More than 3.4 billion gift cards were sold in the United States in 2021.

Almost all these cards are thrown away after the first few days of receiving them, resulting in increased waste in landfills.

Recently, I have been looking into this issue, and I’ve created a solution that can help us reduce paper waste from cards. I’ve used recreated a similar project by Yuma from ‘Anyone Can Code,’ using Apple’s ARKit and Xcode. My project is an augmented birthday card that can be reprogrammed and redesigned based on the person you are gifting it to.

Project Overview:

This project works by installing an app onto my phone. When the code is connected, it opens that app, and goes to a camera-like screen which is constantly searching for the tracking image (in my case, a birthday cake icon from Google). Once this image is detected, an augmented birthday card animation pops up, and essentially “sticks” onto the image in real life. The animation can then play either a video, or display an image.

Here’s a detailed breakdown of how I created it:

Step 1: Set Up

The first step is to install ARKit and Xcode using these two links:

• https://developer.apple.com/augmented-reality/
• https://developer.apple.com/xcode/

Once these finish downloading, you can start running Xcode.

The first thing that you will see are three options; Create New Project, Clone Git Repository, or Open Existing Project. Since we are creating a new project, we can click on the first option.

This leads us to a page that looks like this:

In this case, since our app is going to be an augmented birthday card, we can chose Augmented Reality app.

Once this page pops up, you can set your project name, team, and organization to anything you would like, however, ensure all the other settings are the same as these:

• Interface: Storyboard
• Language: Swift
• Testing System: Swift Testing with XCTest UI Tests
• Content Technology: SceneKit

After this, is will ask you to save your project in your files. For my project, I saved it in my TKS projects folder, since it is accessible and easy to find.

Once you have created your project and saved it into your files, we can start building the project.

Step 2: Visual Birthday Message

The next step is creating the actual project, and making the visual of how you want the birthday card to look.

On the left side of your window, would will find a few starting files. Click on the dropdown next to art.scnassets, and go to the file called ship. You will find a couple pre-installed images, however, we will not be needing them so we can delete those, but keep the actual file itself.

Once you have deleted everything, you should see an empty plane where we can create our animation.

Near the top right corner of the screen, you will find a plus sign, which when clicked, will open a dropdown menu. Drag the empty node into the Scene Graph, and rename it “container.” On the right, you will find a toolbar with options to modify our container. Click on the icon that looks like a cube, and change the Transforms options to look something like this.

This container will serve as our main building space, and will allow us to move around our augmented animation, and make it lay over our tracking image. Within this container, we can drag in two 3D text objects. These texts will be our birthday message. Be sure to name both these objects something similar to “text,” so you can easily write it in the code.

For mine, I made the first one say “Happy Birthday,” and the second one say “Aahana!”

Once everything is put together, the measurements and positions of the texts should be:

Once we have the text set up, we can work on the video. For the video to display, we need to first upload it as an mp4. Within the project file, I uploaded a test video to use as a demonstration.

Now that we have the video file uploaded, we can create a box for the video to actually be shown in. To do this, we need to go back to our Scene Graph, and insert another object called plane. This allows us to display our video in a rectangular frame once the tracking image is detected. Make sure to also go into materials component of this display, and change the shading properties to physically based. This essentially allows us to display a clear image of our video. The measurements and position should look something like this.

An optional step of this process would be to add directional and ambient lighting to the texts, however, this does not change the functionality of the app, so it is not required.

After adding in all these components, we should have a simple visual that looks something like this:

Step 3: AR Resource Group for Image Tracking

In order to create the tracking image, we first need to upload a png of the image we are going to track in real life. Once we have uploaded the image into the project files, we need to print that exact same image (in my case, a birthday cake icon).

Now we can work on building the AR Resource Group. This will allow us to identify the image that we will be tracking.

After creating the project, you should have a file called Assets.xcassets. Inside this file, click on the empty space under Applcon. This should open a dropdown with a few options. Click on AR and Textures, then New AR Resource Group. You can name this new folder AR Resources. You can now drag your tracking image, into the thin rectangle next to the AR Resources file. If a yellow triangle shows up on the bottom right of the image, you will have to click the image and go into attributes inspector to set size values to your image. Whatever image size you set, should correlate to its real world size.

Once you have this AR Resource Group and the visual birthday image set up, you can set up an info.plist file.

Step 4: Info.plist File

This file will allow our device to access the camera for image tracking, and it is simple to implement.

• Right-click on the folder where you want to create the new file.
• Select New File From Template and choose Property List.
• Click Next and name the file Info.plist

Within this file, you will find a Key, Type, and a Value. In the key, enter “NSCameraUsageDescription,” make sure the type is set to string, and set the value to something like “We need access to your camera for augmented reality features.” This lets the program know to enable the camera as soon as the app opens.

Now we are ready for the programming!

Step 5: Programming

All of our code will be in the ViewController.swift file, and will be done in Swift.

1. We can start by importing all our frameworks, or libraries.

import UIKit
import SceneKit
import ARKit
import AVFoundation
import SpriteKit

These libraries will allow us to combine audio/visual elements and custom UI features for our augmented reality app.

2. When you initially open this file, you will see some pre-existing code. You can delete all the code under:

 // Pausing the view's session
 sceneView.session.pause()

At the top of your source code, you should have these lines. If not, make sure you add them in:

class ViewController: UIViewController, ARSCNViewDelegate {
    
    @IBOutlet var sceneView: ARSCNView!
    
    override func viewDidLoad() {
        super.viewDidLoad()

The first line is declaring a class named ViewController which will provide the functionality for the screen that will display our video. Next, we are declaring an IBOutlet, which will connect our code with the UI of our app. The ARSCNView is also going to enable AR content, and the viewDidLoad() function will initially set up our app.

Then, we can work on the audio aspect of our AR video display.

// Set up the audio session to play audio
            do {
                let session = AVAudioSession.sharedInstance()
                try session.setCategory(.playback, mode: .default, options: .mixWithOthers)
                try session.setActive(true)
            } catch {
                print("Audio session setup error: \(error)")
            }

This code will enable the audio on the video we uploaded earlier. The line try session.setActive(true), activates the audio system and tells the app that audio is ready to be played. The line, catch { print(“Audio session setup error: \(error)”) }, handles any errors that may occur during this audio setup session.

The next step would be to set the 3D scene.

  UIApplication.shared.isIdleTimerDisabled = true
        
        // Setting the view's delegate
        sceneView.delegate = self
        
        // Creating a new scene
        let scene = SCNScene(named: "art.scnassets/ship.scn")!
        
        // Setting the scene to the view
        sceneView.scene = scene
}

Some of this code may already be there, however this is important for our 3D scene to show up, so ensure this is in your code. These lines allow us to keep the screen active when we are running our program, prepare the AR view, and load the 3D model that will be displayed.

Now that we have our 3D model loaded, we can work on image tracking.

override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        // Creating a session configuration
        let configuration = ARImageTrackingConfiguration()
        
        guard let arImages = ARReferenceImage.referenceImages(inGroupNamed: "AR Resources", bundle: nil) else { return }
        configuration.trackingImages = arImages
        
        // Running the view's session
        sceneView.session.run(configuration)
    }

This portion of our code does a few things:

• Configures an ARKit session to detect and track 2D images (in our case, the birthday cake image).
• Uses images from our AR Resources Group to reference for image tracking.
• Enables image tracking by running the AR Session.

This basically allows our program to only detect the specific image, an display the AR content only after that image is detected.

Now that we have made the AR content display upon detection of a certain image (birthday cake image), we also have to make it disappear when the image is no longer detected. This is how you would do that:

override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        
        // Pausing the view's session
        sceneView.session.pause()
    }
    
    func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        guard anchor is ARImageAnchor else { return }

After the AR content is able to be displayed and concealed, we can move onto container section.

// Container
        guard let container = sceneView.scene.rootNode.childNode(withName: "container", recursively: false) else { return }
        container.removeFromParentNode()
        node.addChildNode(container)
        container.isHidden = false

This source code allows us to move our 3D object, “container,” to a specific location. In our case, this location would be an AR anchor like the detected image. For this program specifically, we would use this approach to move our video container to the position of the card (once detected).

Once we have completed this step, we can move onto the second last step in programming this app, which is setting up the video on a 3D object in an ARKit SceneKit scene. This can be done with the following code:

// Video
        let videoURL = Bundle.main.url(/service/forresource: "video_test1", withExtension: "mp4")!
        
        let videoPlayer = AVPlayer(url: videoURL)

        
        let videoScene = SKScene(size: CGSize(width: 720.0, height: 1280.0))
        let videoNode = SKVideoNode(avPlayer: videoPlayer)
        videoNode.position = CGPoint(x: videoScene.size.width / 2, y: videoScene.size.height / 2)
        videoNode.size = videoScene.size
        videoNode.yScale = -1
        videoNode.play()
        
        videoScene.addChild(videoNode)
        
        
        guard let video = container.childNode(withName: "video", recursively: true) else { return }
        video.geometry?.firstMaterial?.diffuse.contents = videoScene

This code takes our video file that we uploaded earlier (video_test1) and makes it ready to play in our container.

This step is also combined with an a few more lines to make the video look clear and actually play. When running my code, I realized there was a white hue on the video container that prevented the video from playing clearly. This first line of code fixes this issue:

 // Setting transparency to 1.0 to avoid the white hue on the video
        video.geometry?.firstMaterial?.transparency = 1.0
        
        // Start audio from video
            videoPlayer.play()

Finally, we can work on animations on the 3D nodes of our project.

 // Animations
        guard let videoContainer = container.childNode(withName: "videoContainer", recursively: false) else { return }
        
        guard let text = container.childNode(withName: "text", recursively: false) else { return }
        
        guard let textaahana = container.childNode(withName: "textaahana", recursively: false) else { return }
        
        videoContainer.runAction(SCNAction.sequence([SCNAction.wait(duration: 1.0), SCNAction.scale(to: 1.0, duration: 0.5)]))
        text.runAction(SCNAction.sequence([SCNAction.wait(duration: 1.5), SCNAction.scale(to: 0.08, duration: 0.5)]))
        textaahana.runAction(SCNAction.sequence([SCNAction.wait(duration: 2.0), SCNAction.scale(to: 0.07, duration: 0.5)]))
        
    }
    
}

Overall, this code does a few things:

• videoContainer — Waits 1 second, then scales up to full size.
• text — Waits 1.5 seconds, then scales down to 8% of its size.
• textaahana — Waits 2 seconds, then scales down to 7% of its size.

These lines allow for simple animations in our app, but can be modified to implement more interesting features in the future.

Once you have added all the code, you can now move onto the last step of developing our app.

Step 6: Testing

In order to test your app, go to the top on the window and select IOS Devices. Here, you can select the device you want to pair your program with. Once your device is connected, upon running the program, an app should install in our device. This app will open up and start a camera-like display, and once the tracking image is shown on the screen, your AR content should be displayed.

Here’s a video of me going through the programming and design behind this project:

Overall Experience

Despite the final product looking simple and easy, this project has taken me a few weeks to build, with every day coming with a new learning opportunity. I got a chance to learn Swift, and how to use applications such as ARKit, which I never would have even known about. Overall, I really enjoyed working on this project, and I would love to expand my knowledge in the future by improving the AR Birthday Card App (maybe even displaying an interactive game tailored to the recipient of the card👀)!

About The Author

Hey there! My name is Aahana Patel, a 15-year old exploring the intersection of AI in VR/AR. I’m super passionate about creating life-like digital experiences, that contort the boundaries between what’s real and what’s virtual. I hope to one day create a digital utopia for people to connect with friends and family in a way like never before.

If you enjoyed this article, be sure to stay in touch with my profile for more interesting tech. If you wish to connect, you can find my LinkedIn below!

LinkedIn: https://www.linkedin.com/in/aahanapatel/

References

Wholf, T. J. (2022, 11 25). Paper or plastic? Gift cards don’t need to be trash. abcNEWS. https://abcnews.go.com/Business/paper-plastic-gift-cards-trash/story?id=93502280

Yuma. (2018, 09 22). ARKit Image Tracking Tutorial. YouTube. https://www.youtube.com/watch?v=3FKzSYAGfJ0&t=167s

Augmented Wishes: Saving Trees One Birthday Card at a Time was originally published in Antaeus AR on Medium, where people are continuing the conversation by highlighting and responding to this story.

Envision a world where we unlock artificial realism that blends the boundary between virtual and reality. Well this utopia is currently being created in the form of advanced 3D rendering technologies.

What is a Neural Network?

This is a term I’m sure is familiar when we talk about deep learning, however, the meaning is still unknown to many. The name neural network is derived from the human brain, and the concept of these networks is closely related to the function of our brains as well. From the name alone, we can understand that it is a network of neurons. In this context, a neuron is essentially a unit that processes information.

A network contains 4 main types of layers:

• The input layer is where the network receives data, such as images, sounds, text, etc. From here, this data is converted to a numerical format for the network to be able to understand.
• Next comes one or more hidden layers, depending on the complexity of the task. These hidden layers are responsible for analyzing the input with artificial neurons. Each individual neuron detects patterns within the input data, and is able to identify distinct aspects that help us understand the input data; similar to the human brain.
• After analyzing this data, the neurons pass the information through the activation function, deciding whether or not to send a signal, based on the received data. This layer ensures that our model can solve real-world problems, by introducing non-linearity. A model without this layer would only be able to solve problems where the relationship between input and output is linear. This allows our model to learn complex patterns and make more accurate predictions.
• Finally, the output layer provides us with the final decision or prediction, based on what the network has learned with the data.

For this model to learn and make more accurate predictions in the future, the network needs to be trained. During this process, the network is fed large amounts of data, through which it has to make predictions, while comparing it to the correct answer. This process of error minimization is called backpropagation, and it essentially ensures that our network can provide precise results.

What is a Neural Radiance Field (NeRF)?

NeRFs are essentially a use of neural networks specially designed for synthesizing high-quality 3D scenes from 2D images. By taking 2D pictures of something from different angles, NeRFs are able to take that data, and generate smooth 3D representations of that scene. NeRFs focus on something called volumetric rendering. This means that it models how light moves through a space, rather than having to rely on polygonal structures like traditional 3D models. This technique allows NeRFs to have the upper-hand when creating highly detailed models, with complex lighting and shadows.

Step by step explanation:

1. Input: A NeRF requires multiple 2D images taken from different angles. An input for a NeRF would be something like a 3D coordinate and the direction of the camera (described as a vector).
2. Architecture: NeRFs require multiple hidden layers of artificial neurons within its neural networks. The input layer consists of the viewing directions and 3D positions. The hidden layers process the input and access how the lighting plays with the environment. The network then outputs important information about the input points. The RGB colour, and the density, or how much light is being absorbed at that point.
3. Volume Rendering: Once thee two values are estimated, we need to combine them. This technique is used to take all the colours and densities along a ray of light from the camera, through to the 3D points that are intersected. Meaning that as the light ray moves, NeRFs are able to predict the colour and density at every point along that path.
4. Training: NeRFs are trained using a set of images, like the picture of input images above. During this process, the network uses backpropagation to learn to predict the colours and density at any given point, and be able to reduce differences between the predictions, and the actual 2D input images. After training the NeRF, it is able to produce photorealistic 3D representations with various viewpoints just based off of a couple 2D input images.
5. Output: As mentioned, after the training process, NeRFs are able to accurately synthesize new views of a scene, regardless of whether or not the training data showed that angle of the scene already. In a virtual setting, you may move the camera wherever, and the NeRF is able to predict what that angle would look like, based on its training.

In figure 3 for example, the system starts with input information, which includes the position and direction. This information is passed through a neural network. The network then predicts colour (RGB) and the density (how transparent or solid the point is). From here, it simulates the rays of light that pass through the scene. By combining all these effects of rays, we can create an image of a scene from a specific viewpoint. The rendering loss layer basically compares the generated image to the given input, and calculates any errors, which are called “loss”. This loss is then used to adjust the network and make it more accurate for future results.

Disadvantages of NeRFs

Despite being able to achieve photorealism and generate hyper-realistic 3D representations of 2D images, NeRFs have their downsides.

• High Computational Demand: NeRFs require a lot of power to train and render. A NeRF model can take hours or even days to train, and rendering can be very slow because the NeRF need to trace rays and compute colours and density while doing so.
• Data Requirements: In order for NeRFs to create accurate 3D representations, it requires a large amount of high-resolution images from multiple angles. Without this data, the scene can become choppy, and not properly constructed.
• Memory Usage: For complex scenes, NeRF models tend to be memory-intensive. The model can become extremely large once the scene grows in detail, size and complexity, making NeRFs overly large.
• Dynamic Scene Rendering: NeRFs are usually designed to handle static scenes meaning objects don’t move or change over time. Updating models in real-time can be difficult since they aren’t designed to work with dynamic scenes.

Introducing Gaussian Splatting

Gaussian Splatting is an advanced technique used for 3D rendering and scene reconstruction. This technique is often used as a faster and more flexible alternative to traditional NeRFs, as they have their advantages.

Breakdown of How it Works:

1. Scene Representation: Instead of using a collection of grid points like NeRFs, Gaussian Splatting uses 3D Gaussian Distributions. Each Gaussian is described by the position (the 3D location within the scene), colour density (RGB value, and how the light is absorbed), and size & shape (how “blurry” or “sharp” the scene would be in a particular spot).
2. Projection onto a 2D Image Plane: Gaussian Splatting works by projecting each Gaussian “blob” onto the camera view. This is essentially telling us how each Gaussian would appear from different viewpoints of the camera. Visually, on the image plane, a Gaussian can appear as an elliptical spot, or a “splat” as shown below.
3. Blending Gaussians: After these splats are projected onto a 2D plane, they are blended together based on their positions in 3D space. By blending the colours and densities and creating that gradual transition, we can achieve a smooth, seamless image, like the one above.
4. Handling Camera Rays: Similar to NeRFs, Gaussian Splatting works by simulating rays of light that pass through the scene. However, unlike NeRFs, rather than tracing these rays through grids, Gaussian Splatting calculates how each Gaussian contributes to each individual light ray, by considering the colour and density.

Once all the Gaussians are blended and projected on to the 2D plane, the result is a realistic rendering of the 3D scene from the current camera angle.

Is Gaussian Splatting Better than NeRFs?

There are often times when speed, adaptability, and efficiency are needed, and Gaussian Splatting is sometimes seen as a better alternative to traditional NeRFs.

Let’s walk through why Gaussian Splatting often outperforms NeRFs:

1. Real-Time Rendering: When it comes to rendering new views or angles of a scene, Gaussian Splatting is far more efficient than NeRFs. The real-time rendering that Gaussian Splatting does is crucial for interactive applications such as live simulations and VR/AR.
2. More Simple Computation: Gaussian Splatting represents a scene using 3D Gaussian Distributions, unlike NeRFs that use grids or volumetric models. Each Gaussian is a simple structure that represents colour, density, and shape efficiently. However, NeRFs require complex algorithms that calculate how light passes through each volumetric pixel (voxel) in a grid. This can be both time consuming and expensive.
3. Rendering Complex Scenes: As I mentioned earlier, NeRFs are trained to handle static scenes, and any changes to the scene would require the model to be re-trained for accurate 3D representation. Gaussian Splatting on the other hand, is better suited for dynamic elements, and can adapt to changing scenes without having to be completely re-trained.
4. Data Requirements: NeRFs require large amount of data in the form of 2D images from various angles to be able to accurately represent a scene. Gaussian Splatting however, uses flexible and light-weight Gaussian representation, which allows it to work with the small data sets more effectively.
5. Memory: Compared to NeRF’s volumetric grids, Gaussian Blobs are much more memory efficient due to their ability to work with smaller data sets. This can allow Gaussian Splatting to render complex scenes using less resources.
6. Training Time: Gaussian Splatting uses simpler mathematical models, and doesn’t require some of the complex techniques that NeRFs use. Once the 3D Gaussians are defined, we are able to project and render them quickly. However, while NeRFs are capable of producing high-quality scenes, they require large amounts of training data time, which limits their application.

What Does This Mean for Us?

Techniques such as Gaussian Splatting are reforming how we create hyper-realistic, immersive virtual environments. This technique specifically provides a fast, efficient, and flexible method of representing 3D scenes. Instead of having to rely on traditional rendering techniques that involve sharp polygons, or dense grids of voxels, Gaussian Splatting uses smooth and light blobs to describe the interaction of light within a 3D space. In turn, we are left with smooth blending, fast computation, and efficiency in memory. This approach is revolutionizing the 3D rendering industry, and is bringing new heights to quality and speed of visual production.

Where Can Gaussian Splatting Be Used?

1. Virtual Reality (VR) and Augmented Reality (AR): Rendering life-like virtual worlds requires advanced 3D rendering techniques. Gaussian Splatting can improve the realism in VR/AR, and make the overall experience much more seamless.
2. Visual Effects (VFX): In film production, Gaussian Splatting can allow us to render special visual effects, where efficient blending is crucial to achieve that “real” look.
3. Scientific Visualization: In fields such as astronomy, medical imaging, and particle physics, Gaussian Splatting can help us visualize data in a continuous way, without making it overly complex with geometry (like NeRFs).

TL;DR

In a world where immersive technologies are constantly advancing, techniques such as Gaussian Splatting and NeRFs are transforming 3D rendering. NeRFs (Neural Radiance Fields) generate seamless 3D representations with 2D input images by using neural networks, and are able to produce highly-detailed scenes. On the other hand, Gaussian Splatting uses 3D Gaussian Blobs that create smooth scenes. Ultimately, both technologies have their advantages, however, Gaussian Splatting is starting to become the preferred choice due to its speed and efficiency.

About The Author

Hey there! My name is Aahana Patel, a 15-year old exploring the intersection of AI in VR/AR. I’m super passionate about creating life-like digital experiences, that contort the boundaries between what’s real and what’s virtual. I hope to one day create a digital utopia for people to connect with friends and family in a way like never before.

If you enjoyed this article, be sure to stay in touch with my profile for more interesting tech. If you wish to connect, you can find my LinkedIn below!

LinkedIn: https://www.linkedin.com/in/aahanapatel/

References

[2003.08934] NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis. (2020, March 19). arXiv. Retrieved October 13, 2024, from https://arxiv.org/abs/2003.08934

[2308.04079] 3D Gaussian Splatting for Real-Time Radiance Field Rendering. (2023, August 8). arXiv. Retrieved October 13, 2024, from https://arxiv.org/abs/2308.04079

Al-Masri, A., & Urwin, M. (n.d.). Backpropagation in a Neural Network: Explained. Built In. Retrieved October 13, 2024, from https://builtin.com/machine-learning/backpropagation-neural-network

An Intro to Gaussian Splats — Scaniverse. (2024, September 26). Scaniverse. Retrieved October 13, 2024, from https://scaniverse.com/news/intro-gaussian-splats

Basic Understanding of Neural Network Structure | by Sarita, PhD. (2023, October 3). Medium. Retrieved October 13, 2024, from https://medium.com/@sarita_68521/basic-understanding-of-neural-network-structure-eecc8f149a23

Brennan, M. (2024, March 14). 3D Gaussian Splatting! — Computerphile. YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=VkIJbpdTujE

But what is a neural network? | Chapter 1, Deep learning. (2017, October 5). YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=aircAruvnKk

Facebook is building the future of connection with lifelike avatars. (n.d.). Tech at Meta. Retrieved October 13, 2024, from https://tech.facebook.com/reality-labs/2019/3/codec-avatars-facebook-reality-labs/

Gaussian Splatting and the Future of Photogrammetry — Innoarea Projects. (n.d.). Innoarea Projects. Retrieved October 13, 2024, from https://innoarea.com/en/noticias/gaussian-splatting/

Greenwald, W. (2023, June 6). Augmented Reality (AR) vs. Virtual Reality (VR): What’s the Difference? PCMag. Retrieved October 13, 2024, from https://www.pcmag.com/news/augmented-reality-ar-vs-virtual-reality-vr-whats-the-difference

NERFs (No, not that kind) — Computerphile. (2023, December 21). YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=wKsoGiENBHU

NeRF: Neural Radiance Fields. (n.d.). Matthew Tancik. Retrieved October 13, 2024, from https://www.matthewtancik.com/nerf

Parmar, R. (2018, September 11). Training Deep Neural Networks. Deep Learning Accessories | by Ravindra Parmar. Towards Data Science. Retrieved October 13, 2024, from https://towardsdatascience.com/training-deep-neural-networks-9fdb1964b964

Regalbuto, A. (2023, December 8). The rise of 3D Gaussian Splatting: what is it and how is it changing the immersive media industry? — Magnopus. Magnopus. Retrieved October 13, 2024, from https://www.magnopus.com/blog/the-rise-of-3d-gaussian-splatting

Takacs, D. (2024, August 27). 2 Visual Effects using Gaussian Splatting and AI. YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=srNT6DIjcD4

3D Gaussian Splatting — Explained! (2023, November 5). YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=sQcrZHvrEnU

3D Gaussian Splatting — Why Graphics Will Never Be The Same. (2023, August 31). YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=HVv_IQKlafQ

What is a Neural Network? (n.d.). IBM. Retrieved October 13, 2024, from https://www.ibm.com/topics/neural-networks

What is 3D Gaussian Splatting? (2023, September 28). YouTube. Retrieved October 13, 2024, from https://www.youtube.com/watch?v=Tnij_xHEnXc

Yurkova, K. (2023, December 23). A Comprehensive Overview of Gaussian Splatting | by Kate Yurkova. Towards Data Science. Retrieved October 13, 2024, from https://towardsdatascience.com/a-comprehensive-overview-of-gaussian-splatting-e7d570081362#fbb7

The Battle For Realism in 3D Rendering: A Brief Overview of NeRFs vs. Gaussian Splatting was originally published in Antaeus AR on Medium, where people are continuing the conversation by highlighting and responding to this story.