Function main

examples/optix/denoiser/src/main.rs:23–98

()

}

fn main() -> Result<(), Box<dyn Error>> {
    let opt = Opt::from_args();
    let name = opt
        .input
        .file_name()
        .expect("input was not a file")
        .to_string_lossy()
        .to_string();
    let img = Reader::open(opt.input)?.decode()?;

    let mut rgb = img.into_rgb8();
    let mut linear = vec![Vec3::<f32>::zero(); rgb.as_raw().len()];

    let width = rgb.width();
    let height = rgb.height();

    rgb.pixels()
        .zip(linear.iter_mut())
        .for_each(|(rgb, linear)| {
            let rgbvec = Vec3::<u8>::from(rgb.0);
            *linear = rgbvec.numcast::<f32>().unwrap().map(|x| x / 255.0);
        });

    // set up CUDA and OptiX then make the needed structs/contexts.
    let cuda_ctx = cust::quick_init()?;
    optix::init()?;
    let optix_ctx = DeviceContext::new(&cuda_ctx, false)?;

    let stream = Stream::new(StreamFlags::NON_BLOCKING, None)?;

    // set up the denoiser, choosing Ldr as our model because our colors are in
    // the 0.0 - 1.0 range.
    let mut denoiser = Denoiser::new(&optix_ctx, DenoiserModelKind::Ldr, Default::default())?;

    // setup the optix state for our required image dimensions. this allocates the required
    // state and scratch memory for further invocations.
    denoiser.setup_state(&stream, width, height, false)?;

    // allocate the buffer for the noisy image and copy the data to the GPU.
    let in_buf = linear.as_slice().as_dbuf()?;

    let mut out_buf = DeviceBuffer::<Vec3<f32>>::zeroed((width * height) as usize)?;

    // make an image to tell OptiX about how our image buffer is represented
    let input_image = Image::new(&in_buf, ImageFormat::Float3, width, height);

    // Invoke the denoiser on the image. OptiX will queue up the work on the
    // CUDA stream.
    denoiser.invoke(
        &stream,
        Default::default(),
        input_image,
        DenoiserParams::default(),
        &mut out_buf,
    )?;

    // Finally, synchronize the stream to wait until the denoiser is finished doing its work.
    stream.synchronize()?;