About

Render filters are used to post-process rendered images. They are currently used to implement the denoiser filter.

The filter interfaces are defined in the render_filter.framework.

FilterContex

A FilterContexRef is the central class to create and use images, filters and queues.

maxon::FilterContextInterface::Init(): Initializes the context.
maxon::FilterContextInterface::CreateImage(): Creates an images based on the given description.
maxon::FilterContextInterface::CreateFilter(): Creates a filter based on the filter ID.
maxon::FilterContextInterface::CreateCommandQueue(): Creates a command queue.
maxon::FilterContextInterface::ExecuteCommandQueue(): Executes the filters in the given command queue.

Context implementations are found at the maxon::FilterContextClasses registry:

maxon::FilterContextClasses::OIDNCONTEXT: Open Image Denoiser context implementation.

Queue

A command queue allows queuing of multiple filters.

maxon::FilterCommandQueueInterface::AttachFilter(): Enqueues the given filter.
maxon::FilterCommandQueueInterface::AttachFilterRect(): Enqueues the filter to operate on the given region of the image.
maxon::FilterCommandQueueInterface::DetachFilter(): Detaches the filter from the queue.

Queue implementations are found at the maxon::FilterCommandQueueClasses registry:

maxon::FilterCommandQueueClasses::OIDNFILTERCOMMANDQUEUE: Open Image Denoiser queue implementation.

Filter

The maxon::FilterInterface allows to use a render filter.

maxon::FilterInterface::Set(): Sets a filter parameter.
maxon::FilterInterface::Execute(): Executes the filter.
maxon::FilterInterface::SetProgressMonitor(): Sets a progress monitor function that gets invoked during execution.

Filter implementations are found at the maxon::FilterClasses registry:

maxon::FilterClasses::OIDNFILTERRT: Intel Denoiser Raytracing implementation.

FilterImage

A filter image contains the actual image data.

maxon::FilterImageInterface::WriteToBuffer(): Writes the image data into the given buffer.
maxon::FilterImageInterface::ReadFromCPUMemory(): Copies the image data from the given buffer.
maxon::FilterImageInterface::WriteToFile(): Writes the image data to a file.

Image implementations are found at the maxon::FilterImageClasses registry:

maxon::FilterImageClasses::OIDNFILTERIMAGE: Open Image Denoiser image implementation.

An image is created with maxon::FilterContextInterface::CreateImage() using these parameters:

maxon::FilterImageDescriptionParameters::WIDTH: Image width.
maxon::FilterImageDescriptionParameters::HEIGHT: Image height.

Open Image Denoiser parameters

The Open Image Denoiser filter can further be configured with these parameters:

maxon::OIDNFilterParameter::HDR: If the input data is in hight dynamic range.
maxon::OIDNFilterParameter::SRGB: True if the color data is in sRGB.
maxon::OIDNFilterParameter::ALBEDO: Albedo buffer.
maxon::OIDNFilterParameter::NORMAL: Normal buffer.

Example

  // This example copies the given BaseBitmap into the color buffer and
  // applies the Intel denoiser filter to the image.
 
  // source image buffer
  maxon::BaseArray<maxon::Vector4d32> bufferColor;
  bufferColor.Resize(pixelCount) iferr_return;
 
  // target image buffer
  maxon::BaseArray<maxon::Vector4d32> bufferDenoised;
  bufferDenoised.Resize(pixelCount) iferr_return;
 
  // covnert BaseBitmap to array
 
  MAXON_SCOPE
  {
    Int pos = 0;
 
    for (Int32 y = 0; y < height; ++y)
    {
      for (Int32 x = 0; x < width; ++x)
      {
        UInt16 r, g, b = 0;
 
        bitmap->GetPixel(x, y, &r, &g, &b);
 
        const Float32 rf = Float32(r) / 255.9f;
        const Float32 gf = Float32(g) / 255.9f;
        const Float32 bf = Float32(b) / 255.9f;
        const maxon::Vector4d32 color { rf, gf, bf, 1.00f };
 
        bufferColor[pos] = color;
 
        ++pos;
      }
    }
  }
 
  // get context for Intel Open Image Denoise
  maxon::FilterContextRef filterContext = maxon::FilterContextClasses::OIDNCONTEXT().Create() iferr_return;
  filterContext.Init()    iferr_return;
 
  // create command queue
  maxon::FilterCommandQueueRef commandQueue = filterContext.CreateCommandQueue() iferr_return;
 
  // create filter
  maxon::FilterRef filter = filterContext.CreateFilter(maxon::FilterClasses::OIDNFILTERRT.GetId()) iferr_return;
 
  // create images
 
  maxon::DataDictionary imgDesc;
  imgDesc.Set(maxon::FilterImageDescriptionParameters::WIDTH, static_cast<UInt32>(width)) iferr_return;
  imgDesc.Set(maxon::FilterImageDescriptionParameters::HEIGHT, static_cast<UInt32>(height)) iferr_return;
 
  maxon::FilterImageRef beauty = filterContext.CreateImage(imgDesc) iferr_return;
  maxon::FilterImageRef output = filterContext.CreateImage(imgDesc) iferr_return;
 
  // Load image data
  beauty.ReadFromCPUMemory(bufferColor) iferr_return;
 
  // execute queue
  commandQueue.AttachFilter(filter, beauty, output) iferr_return;
  filterContext.ExecuteCommandQueue(commandQueue) iferr_return;
 
  // get result image
  output.WriteToBuffer(bufferDenoised) iferr_return;

Table of Contents