Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

This is the EXACT feature we needed! 🎬🔥 Jonathan Lampel delivering on the #1 requested Render Raw feature! Per-camera layer binding is absolutely GENIUS for complex multi-camera setups! ⚡ ‼️Link In Comments‼️ #b3d #geometrynode #proceduralart #3dart #blender質 #3d #3Danimation #geonodes #B3D

20,048 Aufrufe • vor 7 Monaten •via X (Twitter)

0 Kommentare

Keine Kommentare verfügbar

Kommentare vom Original-Post werden hier angezeigt

Ähnliche Videos

📢📢 𝐀𝐯𝐚𝐭𝟑𝐫 📢📢 Avat3r creates high-quality 3D head avatars from just a few input images in a single forward pass with a new dynamic 3DGS reconstruction model. Video: Project: Our core idea is to make Gaussian Reconstruction Models animatable. We find that a simple cross-attention to an expression code sequence is already sufficient to model complex facial expressions. We then incorporate position maps from DUSt3R and feature maps from Sapiens to facilitate the prediction task. While DUSt3R's position maps act as a pixel-aligned initialization for the Gaussians' positions, the Sapiens feature maps help the cross-view transformer to match corresponding image tokens in the 4 input images. One major challenge in creating a 3D head avatar from smartphone images comes from inconsistent facial expressions when the subject could not remain perfectly static during the capture. We eliminate this static requirement by simply showing our model input images with different facial expressions during training. This technique makes our model robust to inconsistent input images later on. Finally, we show that despite the model has been trained with 4 input images, one can even create a 3D head avatar when only a single image is available. To achieve this, we employ a pre-trained 3D GAN to lift the single image to 3D and then render the 4 input images for our model. This allows us to create 3D head avatars from single images and even highly out-of-distribution examples like AI generated faces, paintings or statues. Great work by Tobias Kirschstein from his internship at Meta with Javier Romero, Artem Sevastopolsky, and Shunsuke Saito

Matthias Niessner

74,763 Aufrufe • vor 1 Jahr

[SIGGRAPH 2025] Photoreal Scene Reconstruction from an Egocentric Device Contributions: 1. We address the importance of employing visual-inertial bundle adjustment (VIBA) that accounts for the rolling-shutter behavior of the RGB camera. This provides a continuous camera trajectory to model pixel movement in neural reconstruction. Our experiments demonstrate that using VIBA consistently improves the novel view quality in Gaussian Splatting by +1 dB in PSNR. 2. We introduce a rasterization-based image formulation pipeline that addresses common artifacts in physical image formation, including rolling shutter, lens shading, exposure, and gain compensation. Our approach is distinct in that we represent image poses as posed pixel arrays sampled from a continuous trajectory, rather than assigning a single camera pose per image, and preserve the merit of Gaussian rasterization. Unlike existing methods that require ray-tracing Gaussians, e.g., [Moenne-Loccoz et al. 2024], our formulation is applicable to general-purpose rasterization-based Gaussian splatting. When applied to 3D Gaussian Splatting (3DGS) [Kerbl et al. 2023], our approach can further enhance reconstruction quality by +1 dB. We outperform existing baselines and demonstrate a substantial quality improvement in handling complex scenes observed by egocentric devices. 3. To reduce the effect of blur from rapid head motion in darker indoor scenes, we propose a strategy of deliberately underexposing input videos during capture, inspired by HDR+ [Hasinoff et al. 2016]. We demonstrate that we can reconstruct high-quality, noise-free scene radiance from noisy, dim input videos, and further render sharp, blur-free videos at a higher dynamic range.

MrNeRF

15,244 Aufrufe • vor 1 Jahr

ResNet by hand ✍️ ~ 10 steps walkthrough below "Deep Residual Learning for Image Recognition" (Kaiming He, CVPR 2016) is among the most cited papers in all of deep learning. Why does it matter so much? It fixed the exploding and vanishing gradients that kept deep networks from being deep, and made thousands of layers possible. How simple was the fix? An identity matrix. Goal: push three input vectors through a residual block, then through a transformer encoder block, filling in every cell yourself. = 1. Given = A mini batch of three input vectors, 3D, and the weights of the layers ahead. = 2. Linear layer = Let us multiply by the weights, add the bias, and apply ReLU so negatives become 0. Three feature vectors out. This is F(X). = 3. Concatenate = Now the trick. Stack an identity matrix beside the second layer's weights, and stack the input vectors under the features. Draw the lines between rows and columns: those are the skip connections. The identity is the residual. = 4. Linear layer + identity = We multiply the two stacked matrices. The identity carries X straight through while the weights transform it, so a single multiplication computes F(X) + X. Apply ReLU and hand it to the next block. Now watch the same trick inside a transformer, first in attention. = 5. Attention = Let us take three input vectors in 2D, compute the attention matrix, and multiply to get attention weighted vectors. = 6. Concatenate = We stack two identities this time, two residuals, which is how you get 1 + 1, and stack the input vectors with the attention weighted ones. = 7. Add = Multiply the stacked matrices. The identity adds attention to its own input, across the columns, which is how positions get combined. And again in the feed forward layer. = 8. First layer = Let us multiply by the feed forward weights and bias, then ReLU. Three feature vectors. = 9. Concatenate = Stack and link exactly as in step 3: the residual again. = 10. Second layer + identity = We multiply, apply ReLU, and pass the result to the next encoder block. This identity adds across the rows, combining features rather than positions. Takeaway: one simple "add" is what made really deep networks possible. 💾 Save this post!

Tom Yeh

18,049 Aufrufe • vor 1 Monat

Great question! 🤔 How do you simulate *multiple* layers of glass/refraction in video games? In the last breakdown, I discussed how to create a glass shader in Unity URP. In essence, we were taking the render of the scene from the camera without any transparent objects. This is available in URP as the global _CameraOpaqueTexture. This is good enough for most use-cases, and more or less the classic way of doing it. 🔍 What is _CameraOpaqueTexture? As the name implies, there are no transparent objects rendered into this texture, so it's not possible by default to have something like a transparent-type ocean material/shader rendered through a refractive glass shader (which samples and distorts this texture to render on its surface, as if it's transparent). ⚠️ Why it’s tricky: It's much easier to sort without much further setup if you don't have refraction, and only a transparent material, because in that case you're not simulating the transparency yourself via sampling the rendered scene texture. But for refraction, it's required-- unless you want to go down the ray/path tracing route. You could simulate accurate, real dispersion... and that's about as expensive as it sounds, and it requires a rework of your entire rendering. --> 🚫 It's not a viable suggestion to offer. 📚 There are well-known terms regarding transparency sorting you can search up, but as you've specifically asked for refractive boxes, I'll discuss briefly about that. 🧱 Simulating layers of refraction: For this kind of rendering, you need some way to render the backfaces before rendering the front. And the backfaces that are rendered may contain whatever data you'd like for additional processing in the layer front-facing mesh render. 🧪 Examples: You could render the back face as a glass shader of its own, as an intermediate step after _CameraOpaqueTexture. Then you sample this texture instead and you end up with multi-layered refraction, "just like that". You can also render the back normals only, via a fully opaque shader, and use that to manually account for that during the front render. You could even bake in data needed for thickness in realtime. 🛠️ Without making it complicated for yourself, the most straightforward method is via render textures, and you can easily set some fractional resolution. Cameras in Unity have an open slot for target textures to render to. You can use custom render textures to process _SelfTexture2D. ⏱️ It's great to do low-resolution processing for more complex tasks, like blurring and caustics. You can get massive performance boosts, considering the square law and number of pixels/fragments that need calculations (quadratic scaling). 🚧 I've not fully exploited the possibilities myself, but research/development with PRISM is ongoing!

Mirza Beig

61,468 Aufrufe • vor 1 Jahr