use nalgebra as na;
use rayon::prelude::*;
use crate::config::RasterConfig;
use crate::gaussian::GaussianModel;
use crate::RenderError;
const SH_C0: f32 = 0.282_094_8;
const SH_C1: f32 = 0.488_602_52;
const SH_C2_0: f32 = 1.092_548_5;
const SH_C2_1: f32 = -1.092_548_5;
const SH_C2_2: f32 = 0.315_391_57;
const SH_C2_3: f32 = -1.092_548_5;
const SH_C2_4: f32 = 0.546_274_24;
const SH_C3_0: f32 = -0.590_043_6;
const SH_C3_1: f32 = 2.890_611_4;
const SH_C3_2: f32 = -0.457_045_8;
const SH_C3_3: f32 = 0.373_176_34;
const SH_C3_4: f32 = -0.457_045_8;
const SH_C3_5: f32 = 1.445_305_7;
const SH_C3_6: f32 = -0.590_043_6;
#[derive(Debug, Clone)]
pub struct CpuCamera {
pub view: na::Matrix4<f32>,
pub proj: na::Matrix4<f32>,
pub position: na::Vector3<f32>,
pub focal: na::Vector2<f32>,
}
#[derive(Debug, Clone)]
struct ProjectedGaussian {
#[allow(dead_code)]
idx: usize,
mean2d: na::Vector2<f32>,
conic: na::Vector3<f32>,
color: na::Vector3<f32>,
opacity: f32,
depth: f32,
}
#[derive(Debug, Clone)]
pub struct CpuRenderOutput {
pub color_data: Vec<f32>,
pub depth_data: Vec<f32>,
pub width: u32,
pub height: u32,
}
pub struct CpuRasterizer {
config: RasterConfig,
}
impl CpuRasterizer {
pub fn new(config: RasterConfig) -> Self {
Self { config }
}
pub fn render(
&self,
model: &GaussianModel,
camera: &CpuCamera,
) -> Result<CpuRenderOutput, RenderError> {
let width = self.config.image_width;
let height = self.config.image_height;
let num_pixels = (width * height) as usize;
let mut projected = Vec::new();
for i in 0..model.len() {
if let Some(g) = self.project_gaussian(model, i, camera)? {
projected.push(g);
}
}
projected.sort_by(|a, b| {
a.depth
.partial_cmp(&b.depth)
.unwrap_or(std::cmp::Ordering::Equal)
});
let pixel_colors: Vec<[f32; 4]> = (0..num_pixels)
.into_par_iter()
.map(|pixel_idx| {
let px = (pixel_idx % width as usize) as f32;
let py = (pixel_idx / width as usize) as f32;
self.blend_pixel(px, py, &projected)
})
.collect();
let mut color_data = vec![0.0; num_pixels * 4];
let mut depth_data = vec![0.0; num_pixels];
for (i, pixel_color) in pixel_colors.iter().enumerate() {
color_data[i * 4] = pixel_color[0];
color_data[i * 4 + 1] = pixel_color[1];
color_data[i * 4 + 2] = pixel_color[2];
color_data[i * 4 + 3] = pixel_color[3];
depth_data[i] = 0.0; }
Ok(CpuRenderOutput {
color_data,
depth_data,
width,
height,
})
}
fn project_gaussian(
&self,
model: &GaussianModel,
idx: usize,
camera: &CpuCamera,
) -> Result<Option<ProjectedGaussian>, RenderError> {
let gaussian = &model.gaussians[idx];
let pos = na::Vector3::new(
gaussian.position[0],
gaussian.position[1],
gaussian.position[2],
);
let pos_cam = camera.view.transform_point(&na::Point3::from(pos));
if pos_cam.z > -self.config.near_plane {
return Ok(None);
}
let pos_ndc = camera.proj.transform_point(&pos_cam);
let mean2d = na::Vector2::new(
(pos_ndc.x * 0.5 + 0.5) * self.config.image_width as f32,
(pos_ndc.y * 0.5 + 0.5) * self.config.image_height as f32,
);
let qx = gaussian.rotation[0];
let qy = gaussian.rotation[1];
let qz = gaussian.rotation[2];
let qw = gaussian.rotation[3];
let x2 = 2.0 * qx;
let y2 = 2.0 * qy;
let z2 = 2.0 * qz;
let xx = qx * x2;
let xy = qx * y2;
let xz = qx * z2;
let yy = qy * y2;
let yz = qy * z2;
let zz = qz * z2;
let wx = qw * x2;
let wy = qw * y2;
let wz = qw * z2;
let rotation_matrix = na::Matrix3::new(
1.0 - (yy + zz),
xy - wz,
xz + wy,
xy + wz,
1.0 - (xx + zz),
yz - wx,
xz - wy,
yz + wx,
1.0 - (xx + yy),
);
let scale = na::Vector3::new(
gaussian.scale[0].exp(),
gaussian.scale[1].exp(),
gaussian.scale[2].exp(),
);
let s = na::Matrix3::from_diagonal(&scale);
let m = rotation_matrix * s;
let cov3d = m * m.transpose();
let focal = camera.focal;
let z = pos_cam.z.abs();
let z2 = z * z;
let j = na::Matrix2x3::new(
focal.x / z,
0.0,
focal.x * pos_cam.x / z2,
0.0,
focal.y / z,
focal.y * pos_cam.y / z2,
);
let w = camera.view.fixed_view::<3, 3>(0, 0);
let t = w * cov3d;
let cov2d_full = j * t * w.transpose() * j.transpose();
let cov2d = na::Matrix2::new(
cov2d_full[(0, 0)] + 0.3,
cov2d_full[(0, 1)],
cov2d_full[(1, 0)],
cov2d_full[(1, 1)] + 0.3,
);
let det = cov2d[(0, 0)] * cov2d[(1, 1)] - cov2d[(0, 1)] * cov2d[(1, 0)];
if det.abs() < 1e-10 {
return Ok(None); }
let conic = na::Vector3::new(
cov2d[(1, 1)] / det,
-cov2d[(0, 1)] / det,
cov2d[(0, 0)] / det,
);
let view_dir = (pos - camera.position).normalize();
let color = self.eval_sh(model, idx, view_dir)?;
let opacity = sigmoid(gaussian.opacity);
Ok(Some(ProjectedGaussian {
idx,
mean2d,
conic,
color,
opacity,
depth: -pos_cam.z,
}))
}
fn eval_sh(
&self,
model: &GaussianModel,
idx: usize,
dir: na::Vector3<f32>,
) -> Result<na::Vector3<f32>, RenderError> {
let sh_degree = model.sh_degree.min(3);
let sh_coeffs_per_gaussian = ((sh_degree + 1) * (sh_degree + 1) * 3) as usize;
let sh_start = idx * sh_coeffs_per_gaussian;
if sh_start + sh_coeffs_per_gaussian > model.sh_coeffs.len() {
return Err(RenderError::Rasterize(format!(
"SH coefficient index out of bounds: {} + {} > {}",
sh_start,
sh_coeffs_per_gaussian,
model.sh_coeffs.len()
)));
}
let sh = &model.sh_coeffs[sh_start..sh_start + sh_coeffs_per_gaussian];
let result = match sh_degree {
0 => eval_sh_degree0(sh),
1 => eval_sh_degree1(dir, sh),
2 => eval_sh_degree2(dir, sh),
3 => eval_sh_degree3(dir, sh),
_ => {
return Err(RenderError::Rasterize(format!(
"Invalid SH degree: {}",
sh_degree
)))
}
};
Ok(result)
}
fn blend_pixel(&self, px: f32, py: f32, gaussians: &[ProjectedGaussian]) -> [f32; 4] {
let pixel_f = na::Vector2::new(px + 0.5, py + 0.5);
let mut t = 1.0f32; let mut color = na::Vector3::zeros();
for g in gaussians {
if t < 1.0 / 255.0 {
break; }
let d = pixel_f - g.mean2d;
let power = -0.5
* (g.conic.x * d.x * d.x + 2.0 * g.conic.y * d.x * d.y + g.conic.z * d.y * d.y);
if !(-4.0..=0.0).contains(&power) {
continue; }
let alpha_raw = g.opacity * power.exp();
let alpha = alpha_raw.min(0.99);
if alpha < 1.0 / 255.0 {
continue; }
let weight = t * alpha;
color += weight * g.color;
t *= 1.0 - alpha;
}
let bg = na::Vector3::new(
self.config.background[0],
self.config.background[1],
self.config.background[2],
);
color += t * bg;
[color.x, color.y, color.z, 1.0 - t]
}
}
fn sigmoid(x: f32) -> f32 {
1.0 / (1.0 + (-x).exp())
}
fn eval_sh_degree0(sh: &[f32]) -> na::Vector3<f32> {
let dc = na::Vector3::new(sh[0], sh[1], sh[2]);
(SH_C0 * dc + na::Vector3::new(0.5, 0.5, 0.5)).sup(&na::Vector3::zeros())
}
fn eval_sh_degree1(dir: na::Vector3<f32>, sh: &[f32]) -> na::Vector3<f32> {
let x = dir.x;
let y = dir.y;
let z = dir.z;
let mut result = SH_C0 * na::Vector3::new(sh[0], sh[1], sh[2]);
result += SH_C1 * (-y) * na::Vector3::new(sh[3], sh[4], sh[5]);
result += SH_C1 * z * na::Vector3::new(sh[6], sh[7], sh[8]);
result += SH_C1 * (-x) * na::Vector3::new(sh[9], sh[10], sh[11]);
(result + na::Vector3::new(0.5, 0.5, 0.5)).sup(&na::Vector3::zeros())
}
fn eval_sh_degree2(dir: na::Vector3<f32>, sh: &[f32]) -> na::Vector3<f32> {
let x = dir.x;
let y = dir.y;
let z = dir.z;
let mut result = SH_C0 * na::Vector3::new(sh[0], sh[1], sh[2]);
result += SH_C1 * (-y) * na::Vector3::new(sh[3], sh[4], sh[5]);
result += SH_C1 * z * na::Vector3::new(sh[6], sh[7], sh[8]);
result += SH_C1 * (-x) * na::Vector3::new(sh[9], sh[10], sh[11]);
let xx = x * x;
let yy = y * y;
let zz = z * z;
let xy = x * y;
let yz = y * z;
let xz = x * z;
result += SH_C2_0 * xy * na::Vector3::new(sh[12], sh[13], sh[14]);
result += SH_C2_1 * yz * na::Vector3::new(sh[15], sh[16], sh[17]);
result += SH_C2_2 * (2.0 * zz - xx - yy) * na::Vector3::new(sh[18], sh[19], sh[20]);
result += SH_C2_3 * xz * na::Vector3::new(sh[21], sh[22], sh[23]);
result += SH_C2_4 * (xx - yy) * na::Vector3::new(sh[24], sh[25], sh[26]);
(result + na::Vector3::new(0.5, 0.5, 0.5)).sup(&na::Vector3::zeros())
}
fn eval_sh_degree3(dir: na::Vector3<f32>, sh: &[f32]) -> na::Vector3<f32> {
let x = dir.x;
let y = dir.y;
let z = dir.z;
let mut result = SH_C0 * na::Vector3::new(sh[0], sh[1], sh[2]);
result += SH_C1 * (-y) * na::Vector3::new(sh[3], sh[4], sh[5]);
result += SH_C1 * z * na::Vector3::new(sh[6], sh[7], sh[8]);
result += SH_C1 * (-x) * na::Vector3::new(sh[9], sh[10], sh[11]);
let xx = x * x;
let yy = y * y;
let zz = z * z;
let xy = x * y;
let yz = y * z;
let xz = x * z;
result += SH_C2_0 * xy * na::Vector3::new(sh[12], sh[13], sh[14]);
result += SH_C2_1 * yz * na::Vector3::new(sh[15], sh[16], sh[17]);
result += SH_C2_2 * (2.0 * zz - xx - yy) * na::Vector3::new(sh[18], sh[19], sh[20]);
result += SH_C2_3 * xz * na::Vector3::new(sh[21], sh[22], sh[23]);
result += SH_C2_4 * (xx - yy) * na::Vector3::new(sh[24], sh[25], sh[26]);
result += SH_C3_0 * y * (3.0 * xx - yy) * na::Vector3::new(sh[27], sh[28], sh[29]);
result += SH_C3_1 * x * y * z * na::Vector3::new(sh[30], sh[31], sh[32]);
result += SH_C3_2 * y * (4.0 * zz - xx - yy) * na::Vector3::new(sh[33], sh[34], sh[35]);
result +=
SH_C3_3 * z * (2.0 * zz - 3.0 * xx - 3.0 * yy) * na::Vector3::new(sh[36], sh[37], sh[38]);
result += SH_C3_4 * x * (4.0 * zz - xx - yy) * na::Vector3::new(sh[39], sh[40], sh[41]);
result += SH_C3_5 * z * (xx - yy) * na::Vector3::new(sh[42], sh[43], sh[44]);
result += SH_C3_6 * x * (xx - 3.0 * yy) * na::Vector3::new(sh[45], sh[46], sh[47]);
(result + na::Vector3::new(0.5, 0.5, 0.5)).sup(&na::Vector3::zeros())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sigmoid() {
assert!((sigmoid(0.0) - 0.5).abs() < 1e-6);
assert!(sigmoid(10.0) > 0.99);
assert!(sigmoid(-10.0) < 0.01);
}
#[test]
fn test_sh_degree0() {
let sh = vec![1.0, 0.5, 0.25];
let result = eval_sh_degree0(&sh);
let expected = na::Vector3::new(SH_C0 * 1.0 + 0.5, SH_C0 * 0.5 + 0.5, SH_C0 * 0.25 + 0.5);
assert!((result - expected).norm() < 1e-5);
}
#[test]
fn test_cpu_rasterizer_creation() {
let config = RasterConfig::new().with_resolution(512, 512);
let _rasterizer = CpuRasterizer::new(config);
}
#[test]
fn test_blend_pixel_empty() {
let config = RasterConfig::new().with_resolution(512, 512);
let rasterizer = CpuRasterizer::new(config);
let gaussians = vec![];
let pixel = rasterizer.blend_pixel(0.0, 0.0, &gaussians);
assert_eq!(pixel, [0.0, 0.0, 0.0, 0.0]);
}
}