ReconstructionRenderOutput.cpp

Go to the documentation of this file.

/**<!-------------------------------------------------------------------->
   @file   ReconstructionRenderOutput.cpp
   @author Travis Fischer (fisch0920@gmail.com)
   @author Matthew Jacobs (jacobs.mh@gmail.com)
   @date   Fall 2008
   
   @brief
      Records point samples from a renderer and attempts to reconstruct the 
   underlying image by filtering samples with a reconstruction filter
   <!-------------------------------------------------------------------->**/

#include "ReconstructionRenderOutput.h"
#include "PointSample.h"
#include <SpectralSampleSet.h>

#include <filters.h>
#include <QtCore>

ReconstructionRenderOutput::ReconstructionRenderOutput(Image *output, 
                                                       KernelFilter *f) 
   : RenderOutput(), m_output(output), 
     m_filter(f), m_progressiveValues(NULL)
{
   if (output) {
      const unsigned width  = output->getWidth();
      const unsigned height = output->getHeight();
      
      m_viewport.setSize(width, height);
   }
}

ReconstructionRenderOutput::~ReconstructionRenderOutput() {
   safeDelete(m_filter);
   safeDeleteArray(m_progressiveValues);
}

void ReconstructionRenderOutput::addSample(const PointSample &sample) {
   ASSERT(m_output && m_filter);
   
   const SpectralSampleSet &value = sample.value.getValue<SpectralSampleSet>();
   const unsigned width   = m_output->getWidth();
   const unsigned height  = m_output->getHeight();
   const unsigned half    = (m_filter->getWidth() >> 1);
   unsigned col, row;
   
   m_viewport.getBin(sample.position, col, row);
   
   ASSERT(row < width);
   ASSERT(col < height);
   QMutexLocker lock(&m_mutex);
   
   // progressive, normalized filter
   for(unsigned y = MAX(0, (signed)row - half); y <= MIN(height - 1, row + half); ++y) {
      for(unsigned x = MAX(0, (signed)col - half); x <= MIN(width - 1, col + half); ++x) {
         const real_t weight = m_filter->evaluate(
            Vector2(x - sample.position[0] + 0.5, y - sample.position[1] + 0.5));
         
         if (weight > 0) {
            unsigned offset = y * width + x;
            m_progressiveValues[offset].addSample(value, weight);
            
            const SpectralSampleSet &updated = m_progressiveValues[offset].getValue();
            m_output->setPixel(y, x, updated);
         }
      }
   }
   
   _addSample(sample);
}

void ReconstructionRenderOutput::init() {
   RenderOutput::init();
   ASSERT(m_output);
   
   safeDeleteArray(m_progressiveValues);
   m_progressiveValues = new ProgressiveFilterValue<SpectralSampleSet>
      [m_output->getWidth() * m_output->getHeight()];
   
   if (NULL == m_filter) {
      const std::string &filter = 
         getValue<std::string>("filter", "lanczosSinc");
      
      m_filter = KernelFilter::create(filter, *this);
   }
   
   ASSERT(m_filter);
   m_filter->init();
}