Struct rs_pbrt::core::film::Film

pub struct Film {
    pub full_resolution: Point2i,
    pub diagonal: Float,
    pub filter: Box<Filter>,
    pub filename: String,
    pub cropped_pixel_bounds: Bounds2i,
    pub pixels: RwLock<Vec<Pixel>>,
    /* private fields */
}

Fields

full_resolution: Point2i

The overall resolution of the image in pixels

diagonal: Float

The length of the diagonal of the film’s physical area (specified in mm, stored in meters)

filter: Box<Filter>

A filter function

filename: String

The filename of the output image

cropped_pixel_bounds: Bounds2i

A crop window that may specify a subset of the image to render

pixels: RwLock<Vec<Pixel>>

Implementations

impl Film

pub fn new( resolution: Point2i, crop_window: Bounds2f, filter: Box<Filter>, diagonal: Float, filename: String, scale: Float, max_sample_luminance: Float ) -> Self

pub fn create( params: &ParamSet, filter: Box<Filter>, crop_window: &Bounds2f ) -> Arc<Film>

pub fn get_cropped_pixel_bounds(&self) -> Bounds2i

pub fn get_sample_bounds(&self) -> Bounds2i

Examples found in repository

examples/parse_ass_file.rs (line 210)

fn make_path_integrator(
    filter_width: Float,
    xres: i32,
    yres: i32,
    fov: Float,
    animated_cam_to_world: AnimatedTransform,
    maxdepth: i32,
    pixelsamples: i32,
) -> Option<Box<Integrator>> {
    let some_integrator: Option<Box<Integrator>>;
    let some_camera: Option<Arc<Camera>> =
        make_perspective_camera(filter_width, xres, yres, fov, animated_cam_to_world);
    if let Some(camera) = some_camera {
        let sampler_name: String = String::from("sobol");
        let mut sampler_params: ParamSet = ParamSet::default();
        sampler_params.add_int(String::from("pixelsamples"), pixelsamples);
        let some_sampler: Option<Box<Sampler>> =
            make_sampler(&sampler_name, &sampler_params, camera.get_film());
        if let Some(sampler) = some_sampler {
            // CreatePathIntegrator
            let integrator_params: ParamSet = ParamSet::default();
            let max_depth: i32 = integrator_params.find_one_int("maxdepth", maxdepth);
            let pixel_bounds: Bounds2i = camera.get_film().get_sample_bounds();
            let rr_threshold: Float = integrator_params.find_one_float("rrthreshold", 1.0 as Float);
            let light_strategy: String =
                integrator_params.find_one_string("lightsamplestrategy", String::from("spatial"));
            let integrator = Box::new(Integrator::Sampler(SamplerIntegrator::Path(
                PathIntegrator::new(
                    max_depth as u32,
                    camera,
                    sampler,
                    pixel_bounds,
                    rr_threshold,
                    light_strategy,
                ),
            )));
            some_integrator = Some(integrator);
        } else {
            panic!("Unable to create sampler.");
        }
    } else {
        panic!("Unable to create camera.");
    }
    some_integrator
}

pub fn get_physical_extent(&self) -> Bounds2f

pub fn get_film_tile(&self, sample_bounds: &Bounds2i) -> FilmTile<'_>

pub fn merge_film_tile(&self, tile: &FilmTile<'_>)

pub fn set_image(&self, img: &[Spectrum])

pub fn add_splat(&self, p: Point2f, v: &Spectrum)

pub fn write_image(&self, splat_scale: Float)