Small optimizations in compositor.
authorJeroen Bakker <j.bakker@atmind.nl>
Thu, 12 Jul 2012 19:19:03 +0000 (19:19 +0000)
committerJeroen Bakker <j.bakker@atmind.nl>
Thu, 12 Jul 2012 19:19:03 +0000 (19:19 +0000)
Most of them are not noticeable.

source/blender/compositor/intern/COM_MemoryBuffer.cpp
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
source/blender/compositor/nodes/COM_DefocusNode.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.h
source/blender/compositor/operations/COM_OpenCLKernels.cl
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h

index 572308dd87ffb0a99d112263e1ff3a7caf781eea..0aae8853795b291e1e7e7b43a4fd5ce00c0591ca 100644 (file)
@@ -121,7 +121,7 @@ void MemoryBuffer::writePixel(int x, int y, const float color[4])
        if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
            y >= this->m_rect.ymin && y < this->m_rect.ymax)
        {
-               const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+               const int offset = (this->m_chunkWidth * (y-this->m_rect.ymin) + x-this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
                copy_v4_v4(&this->m_buffer[offset], color);
        }
 }
@@ -131,7 +131,7 @@ void MemoryBuffer::addPixel(int x, int y, const float color[4])
        if (x >= this->m_rect.xmin && x < this->m_rect.xmax &&
            y >= this->m_rect.ymin && y < this->m_rect.ymax)
        {
-               const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+               const int offset = (this->m_chunkWidth * (y-this->m_rect.ymin) + x-this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
                add_v4_v4(&this->m_buffer[offset], color);
        }
 }
index a6f81410b74ed4cfbc2dc0f51fa120bc5d5db649..0496974c64ff45f6d07b3a70e24803b32a0ff13c 100644 (file)
@@ -35,7 +35,7 @@ void SingleThreadedNodeOperation::initExecution()
 
 void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
-       this->m_cachedInstance->read(color, x, y);
+       this->m_cachedInstance->readNoCheck(color, x, y);
 }
 
 void SingleThreadedNodeOperation::deinitExecution()
index 05bf907af5a8644b30dff871fcf72582879e3ef8..65825a60b50f77a41175b154e61e745be2521cca 100644 (file)
@@ -99,9 +99,7 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
 #ifdef COM_DEFOCUS_SEARCH      
        InverseSearchRadiusOperation *search = new InverseSearchRadiusOperation();
        addLink(graph, radiusOperation->getOutputSocket(0), search->getInputSocket(0));
-       addLink(graph, depthOperation, search->getInputSocket(1));
        search->setMaxBlur(data->maxblur);
-       search->setThreshold(data->bthresh);
        graph->addOperation(search);
 #endif
        VariableSizeBokehBlurOperation *operation = new VariableSizeBokehBlurOperation();
@@ -116,7 +114,7 @@ void DefocusNode::convertToOperations(ExecutionSystem *graph, CompositorContext
        addLink(graph, bokeh->getOutputSocket(), operation->getInputSocket(1));
        addLink(graph, radiusOperation->getOutputSocket(), operation->getInputSocket(2));
 #ifdef COM_DEFOCUS_SEARCH
-       addLink(graph, search->getOutputSocket(), operation->getInputSocket(4));
+       addLink(graph, search->getOutputSocket(), operation->getInputSocket(3));
 #endif
        if (data->gamco) {
                GammaCorrectOperation *correct = new GammaCorrectOperation();
index ac91d3336e2fd56b52af4d71c48e2bfe4d5a07a2..a9e8de252978c7cd3e230f267dc62ddf491ebc81 100644 (file)
@@ -194,3 +194,156 @@ bool GaussianBokehBlurOperation::determineDependingAreaOfInterest(rcti *input, R
                return BlurBaseOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
        }
 }
+
+// reference image
+GaussianBokehBlurReferenceOperation::GaussianBokehBlurReferenceOperation() : NodeOperation()
+{
+       this->addInputSocket(COM_DT_COLOR);
+       this->addInputSocket(COM_DT_VALUE);
+       this->addOutputSocket(COM_DT_COLOR);
+       this->setComplex(true);
+       this->m_gausstab = NULL;
+       this->m_inputImage = NULL;
+       this->m_inputSize = NULL;
+}
+
+void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+{
+       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       return buffer;
+}
+
+void GaussianBokehBlurReferenceOperation::initExecution()
+{
+       // setup gaustab
+       this->m_data->image_in_width = this->getWidth();
+       this->m_data->image_in_height = this->getHeight();
+       if (this->m_data->relative) {
+               switch (this->m_data->aspect) {
+                       case CMP_NODE_BLUR_ASPECT_NONE:
+                               this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width);
+                               this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height);
+                               break;
+                       case CMP_NODE_BLUR_ASPECT_Y:
+                               this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_width);
+                               this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_width);
+                               break;
+                       case CMP_NODE_BLUR_ASPECT_X:
+                               this->m_data->sizex = (int)(this->m_data->percentx * 0.01f * this->m_data->image_in_height);
+                               this->m_data->sizey = (int)(this->m_data->percenty * 0.01f * this->m_data->image_in_height);
+                               break;
+               }
+       }
+       
+       updateGauss();
+       this->m_inputImage = this->getInputSocketReader(0);
+       this->m_inputSize = this->getInputSocketReader(1);
+}
+
+void GaussianBokehBlurReferenceOperation::updateGauss()
+{
+       int n;
+       float *dgauss;
+       float *ddgauss;
+       int j, i;
+
+       n = (2 * radx + 1) * (2 * rady + 1);
+
+       /* create a full filter image */
+       ddgauss = new float[n];
+       dgauss = ddgauss;
+       for (j = -rady; j <= rady; j++) {
+               for (i = -radx; i <= radx; i++, dgauss++) {
+                       float fj = (float)j / radyf;
+                       float fi = (float)i / radxf;
+                       float dist = sqrt(fj * fj + fi * fi);
+                       *dgauss = RE_filter_value(this->m_data->filtertype, dist);
+               }
+       }
+       this->m_gausstab = ddgauss;
+}
+
+void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+{
+       float tempColor[4];
+       float tempSize[4];
+       tempColor[0] = 0;
+       tempColor[1] = 0;
+       tempColor[2] = 0;
+       tempColor[3] = 0;
+       float multiplier_accum = 0;
+       MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
+       float *buffer = inputBuffer->getBuffer();
+       int bufferwidth = inputBuffer->getWidth();
+       int bufferstartx = inputBuffer->getRect()->xmin;
+       int bufferstarty = inputBuffer->getRect()->ymin;
+       this->m_inputSize->read(tempSize, x, y, inputBuffers, data);
+       float size = tempSize[0];
+       CLAMP(size, 0.0f, 1.0f);
+       float sizeX = ceil(this->m_data->sizex * size);
+       float sizeY = ceil(this->m_data->sizey * size);
+
+       if (sizeX <= 0.5f && sizeY <= 0.5f) {
+               this->m_inputImage->read(color, x, y, inputBuffers, data);
+               return;
+       }
+       
+       int miny = y - sizeY;
+       int maxy = y + sizeY;
+       int minx = x - sizeX;
+       int maxx = x + sizeX;
+       miny = max(miny, inputBuffer->getRect()->ymin);
+       minx = max(minx, inputBuffer->getRect()->xmin);
+       maxy = min(maxy, inputBuffer->getRect()->ymax);
+       maxx = min(maxx, inputBuffer->getRect()->xmax);
+
+       int step = QualityStepHelper::getStep();
+       int offsetadd = QualityStepHelper::getOffsetAdd();
+       for (int ny = miny; ny < maxy; ny += step) {
+               int u = ny - y;
+               float uf = ((u/sizeY)*radyf)+radyf;
+               int indexu = uf * (radx*2+1);
+               int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth);
+               for (int nx = minx; nx < maxx; nx += step) {
+                       int v = nx - x;
+                       float vf = ((v/sizeX)*radxf)+radxf;
+                       int index = indexu + vf;
+                       const float multiplier = this->m_gausstab[index];
+                       madd_v4_v4fl(tempColor, &buffer[bufferindex], multiplier);
+                       multiplier_accum += multiplier;
+                       index += step;
+                       bufferindex += offsetadd;
+               }
+       }
+
+       mul_v4_v4fl(color, tempColor, 1.0f / multiplier_accum);
+}
+
+void GaussianBokehBlurReferenceOperation::deinitExecution()
+{
+       delete [] this->m_gausstab;
+       this->m_gausstab = NULL;
+       this->m_inputImage = NULL;
+       this->m_inputSize = NULL;
+       
+}
+
+bool GaussianBokehBlurReferenceOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
+{
+       rcti newInput;
+       NodeOperation *operation = this->getInputOperation(1);
+       
+       if (operation->determineDependingAreaOfInterest(input, readOperation, output)) {
+               return true;
+       }
+       else {
+               int addx = this->m_data->sizex+2;
+               int addy = this->m_data->sizey+2;
+               newInput.xmax = input->xmax + addx;
+               newInput.xmin = input->xmin - addx;
+               newInput.ymax = input->ymax + addy;
+               newInput.ymin = input->ymin - addy;
+               return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output);
+       }
+}
+
index d18dd17528d07f9cd9a2b2fcad8e08635d33373a..70148da46db65a3a675a1e4301f66c910feef3e7 100644 (file)
@@ -118,17 +118,19 @@ void GaussianXBlurOperation::deinitExecution()
 bool GaussianXBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
 {
        rcti newInput;
-       rcti sizeInput;
-       sizeInput.xmin = 0;
-       sizeInput.ymin = 0;
-       sizeInput.xmax = 5;
-       sizeInput.ymax = 5;
        
-       NodeOperation *operation = this->getInputOperation(1);
-       if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
-               return true;
+       if (!this->m_sizeavailable) {
+               rcti sizeInput;
+               sizeInput.xmin = 0;
+               sizeInput.ymin = 0;
+               sizeInput.xmax = 5;
+               sizeInput.ymax = 5;
+               NodeOperation *operation = this->getInputOperation(1);
+               if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
+                       return true;
+               }
        }
-       else {
+       {
                if (this->m_sizeavailable && this->m_gausstab != NULL) {
                        newInput.xmax = input->xmax + this->m_rad;
                        newInput.xmin = input->xmin - this->m_rad;
index d2d30da8ddfe7d1ef2b4de0db4c6211a929c8c6f..478495ec3be1be02119110c093b0a9bd8c436949 100644 (file)
@@ -116,17 +116,19 @@ void GaussianYBlurOperation::deinitExecution()
 bool GaussianYBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
 {
        rcti newInput;
-       rcti sizeInput;
-       sizeInput.xmin = 0;
-       sizeInput.ymin = 0;
-       sizeInput.xmax = 5;
-       sizeInput.ymax = 5;
        
-       NodeOperation *operation = this->getInputOperation(1);
-       if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
-               return true;
+       if (!m_sizeavailable) {
+               rcti sizeInput;
+               sizeInput.xmin = 0;
+               sizeInput.ymin = 0;
+               sizeInput.xmax = 5;
+               sizeInput.ymax = 5;
+               NodeOperation *operation = this->getInputOperation(1);
+               if (operation->determineDependingAreaOfInterest(&sizeInput, readOperation, output)) {
+                       return true;
+               }
        }
-       else {
+       {
                if (this->m_sizeavailable && this->m_gausstab != NULL) {
                        newInput.xmax = input->xmax;
                        newInput.xmin = input->xmin;
index 9e0ae0c6ee8a2089100c3cfd65f484627b824e1e..df9297c568be009718149c87ebee3c1a04470b8c 100644 (file)
@@ -45,12 +45,13 @@ void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelS
 {
        float inputColor1[4];
        float inputColor2[4];
-       float value;
+       float inputValue[4];
        
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
+       this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
        
+       float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
        }
@@ -93,13 +94,3 @@ void MixBaseOperation::determineResolution(unsigned int resolution[], unsigned i
        }
        NodeOperation::determineResolution(resolution, preferredResolution);
 }
-
-void MixBaseOperation::clampIfNeeded(float *color)
-{
-       if (this->m_useClamp) {
-               CLAMP(color[0], 0.0f, 1.0f);
-               CLAMP(color[1], 0.0f, 1.0f);
-               CLAMP(color[2], 0.0f, 1.0f);
-               CLAMP(color[3], 0.0f, 1.0f);
-       }
-}
index 05301fd0378ee8bb8764c226a9c11999515220f6..1bba28180177eec8d40e15e55bd57012a932b873 100644 (file)
@@ -40,7 +40,16 @@ protected:
        bool m_valueAlphaMultiply;
        bool m_useClamp;
 
-       void clampIfNeeded(float *color);
+       inline void clampIfNeeded(float *color)
+       {
+               if (m_useClamp) {
+                       CLAMP(color[0], 0.0f, 1.0f);
+                       CLAMP(color[1], 0.0f, 1.0f);
+                       CLAMP(color[2], 0.0f, 1.0f);
+                       CLAMP(color[3], 0.0f, 1.0f);
+               }
+       }
+       
 public:
        /**
         * Default constructor
index cbbb4d0b3f270e17324a76dc0d6b89eecbaa2934..4f43650370d5fb0c849e5e3207dcaedcf609f194 100644 (file)
@@ -112,7 +112,7 @@ __kernel void defocusKernel(__read_only image2d_t inputImage, __read_only image2
                                                tempSize = read_imagef(inputSize, SAMPLER_NEAREST, inputCoordinate).s0;
                                                if (tempSize > threshold) {
                                                        if (tempSize >= fabs(dx) && tempSize >= fabs(dy)) {
-                                                               float2 uv = { 256.0f + dx * 256.0f / tempSize, 256.0f + dy * 256.0f / tempSize};
+                                                               float2 uv = { 256.0f + dx * 255.0f / tempSize, 256.0f + dy * 255.0f / tempSize};
                                                                bokeh = read_imagef(bokehImage, SAMPLER_NEAREST, uv);
                                                                readColor = read_imagef(inputImage, SAMPLER_NEAREST, inputCoordinate);
                                                                color_accum += bokeh*readColor;
index 5d17526185b098a87b7a9aaac75afa87ac65ecb2..99a8e563c69218c6e0e6ff479fa41c250696b52a 100644 (file)
@@ -57,7 +57,7 @@ void VariableSizeBokehBlurOperation::initExecution()
        this->m_inputBokehProgram = getInputSocketReader(1);
        this->m_inputSizeProgram = getInputSocketReader(2);
 #ifdef COM_DEFOCUS_SEARCH
-       this->m_inputSearchProgram = getInputSocketReader(4);
+       this->m_inputSearchProgram = getInputSocketReader(3);
 #endif
        QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
@@ -93,7 +93,7 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
 
 #ifdef COM_DEFOCUS_SEARCH
        float search[4];
-       this->inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, inputBuffers, NULL);
+       this->m_inputSearchProgram->read(search, x/InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, inputBuffers, NULL);
        int minx = search[0];
        int miny = search[1];
        int maxx = search[2];
@@ -127,8 +127,8 @@ void VariableSizeBokehBlurOperation::executePixel(float *color, int x, int y, Me
                                                        float fsize = fabsf(size);
                                                        float dx = nx - x;
                                                        if (fsize > fabsf(dx) && fsize > fabsf(dy)) {
-                                                               float u = (256.0f + (dx/size) * 256.0f);
-                                                               float v = (256.0f + (dy/size) * 256.0f);
+                                                               float u = (256.0f + (dx/size) * 255.0f);
+                                                               float v = (256.0f + (dy/size) * 255.0f);
                                                                inputBokehBuffer->readNoCheck(bokeh, u, v);
                                                                madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetNxNy]);
                                                                add_v4_v4(multiplier_accum, bokeh);
@@ -211,7 +211,7 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *inpu
        searchInput.xmin = (input->xmin / InverseSearchRadiusOperation::DIVIDER) - 1;
        searchInput.ymax = (input->ymax / InverseSearchRadiusOperation::DIVIDER) + 1;
        searchInput.ymin = (input->ymin / InverseSearchRadiusOperation::DIVIDER) - 1;
-       operation = getInputOperation(4);
+       operation = getInputOperation(3);
        if (operation->determineDependingAreaOfInterest(&searchInput, readOperation, output) ) {
                return true;
        }
@@ -228,65 +228,74 @@ bool VariableSizeBokehBlurOperation::determineDependingAreaOfInterest(rcti *inpu
 InverseSearchRadiusOperation::InverseSearchRadiusOperation() : NodeOperation() 
 {
        this->addInputSocket(COM_DT_VALUE, COM_SC_NO_RESIZE); // radius
-       this->addInputSocket(COM_DT_VALUE, COM_SC_NO_RESIZE); // depth
        this->addOutputSocket(COM_DT_COLOR);
        this->setComplex(true);
-       this->inputRadius = NULL;
-       this->inputDepth = NULL;
+       this->m_inputRadius = NULL;
 }
 
 void InverseSearchRadiusOperation::initExecution() 
 {
-       this->inputRadius = this->getInputSocketReader(0);
-       this->inputDepth = this->getInputSocketReader(1);
+       this->m_inputRadius = this->getInputSocketReader(0);
 }
 
 void* InverseSearchRadiusOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) 
 {
        MemoryBuffer * data = new MemoryBuffer(NULL, rect);
+       float* buffer = data->getBuffer();
        int x, y;
-       float width = this->inputRadius->getWidth();
-       float height = this->inputRadius->getHeight();
-               
-       for (x = rect->xmin; x < rect->xmax ; x++) {
-               for (y = rect->ymin; y < rect->ymax ; y++) {
-                       float[4] temp;
+       int width = this->m_inputRadius->getWidth();
+       int height = this->m_inputRadius->getHeight();
+       float temp[4];
+       int offset = 0;
+       for (y = rect->ymin; y < rect->ymax ; y++) {
+               for (x = rect->xmin; x < rect->xmax ; x++) {
                        int rx = x * DIVIDER;
                        int ry = y * DIVIDER;
-                       this->inputRadius->read(temp, rx, ry, memoryBuffers, NULL);
-                       float centerRadius = temp[0];
-                       this->inputDepth->read(temp, rx, ry, memoryBuffers, NULL);
-                       float centerDepth = temp[0];
-                       t[0] = MAX2(rx - this->maxBlur, 0.0f);
-                       t[1] = MAX2(ry - this->maxBlur, 0.0f);
-                       t[2] = MIN2(rx + this->maxBlur, width);
-                       t[3] = MIN2(ry + this->maxBlur, height);
-                       int minx = t[0];
-                       int miny = t[1];
-                       int maxx = t[2];
-                       int maxy = t[3];
-                       int sminx = rx;
-                       int smaxx = rx;
-                       int sminy = ry;
-                       int smaxy = ry;
-                       for (int nx = minx ; nx < maxx ; nx ++) {
-                               for (int ny = miny ; ny < maxy ; ny ++) {
-                                       this->inputRadius->read(temp, nx, ny, memoryBuffers, NULL);
-                                       if (nx < rx && temp[0])
-                                       
-                               }
-                       }
-                       float t[4];
-                       data->writePixel(x, y, t);
+                       buffer[offset] = MAX2(rx - m_maxBlur, 0);
+                       buffer[offset+1] = MAX2(ry- m_maxBlur, 0);
+                       buffer[offset+2] = MIN2(rx+DIVIDER + m_maxBlur, width);
+                       buffer[offset+3] = MIN2(ry+DIVIDER + m_maxBlur, height);
+                       offset += 4;
                }
        }
+//     for (x = rect->xmin; x < rect->xmax ; x++) {
+//             for (y = rect->ymin; y < rect->ymax ; y++) {
+//                     int rx = x * DIVIDER;
+//                     int ry = y * DIVIDER;
+//                     float radius = 0.0f;
+//                     float maxx = x;
+//                     float maxy = y;
+       
+//                     for (int x2 = 0 ; x2 < DIVIDER ; x2 ++) {
+//                             for (int y2 = 0 ; y2 < DIVIDER ; y2 ++) {
+//                                     this->m_inputRadius->read(temp, rx+x2, ry+y2, COM_PS_NEAREST, NULL);
+//                                     if (radius < temp[0]) {
+//                                             radius = temp[0];
+//                                             maxx = x2;
+//                                             maxy = y2;
+//                                     }
+//                             }
+//                     }
+//                     int impactRadius = ceil(radius / DIVIDER);
+//                     for (int x2 = x - impactRadius ; x2 < x + impactRadius ; x2 ++) {
+//                             for (int y2 = y - impactRadius ; y2 < y + impactRadius ; y2 ++) {
+//                                     data->read(temp, x2, y2);
+//                                     temp[0] = MIN2(temp[0], maxx);
+//                                     temp[1] = MIN2(temp[1], maxy);
+//                                     temp[2] = MAX2(temp[2], maxx);
+//                                     temp[3] = MAX2(temp[3], maxy);
+//                                     data->writePixel(x2, y2, temp);
+//                             }
+//                     }
+//             }
+//     }
        return data;
 }
 
 void InverseSearchRadiusOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data) 
 {
        MemoryBuffer *buffer = (MemoryBuffer*)data;
-       buffer->read(color, x, y);
+       buffer->readNoCheck(color, x, y);
 }
 
 void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) 
@@ -299,8 +308,7 @@ void InverseSearchRadiusOperation::deinitializeTileData(rcti *rect, MemoryBuffer
 
 void InverseSearchRadiusOperation::deinitExecution() 
 {
-       this->inputRadius = NULL;
-       this->inputDepth = NULL;
+       this->m_inputRadius = NULL;
 }
 
 void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[], unsigned int preferredResolution[])
@@ -313,10 +321,10 @@ void InverseSearchRadiusOperation::determineResolution(unsigned int resolution[]
 bool InverseSearchRadiusOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
 {
        rcti newRect;
-       newRect.ymin = input->ymin*DIVIDER;
-       newRect.ymax = input->ymax*DIVIDER;
-       newRect.xmin = input->xmin*DIVIDER;
-       newRect.xmax = input->xmax*DIVIDER;
+       newRect.ymin = input->ymin*DIVIDER - m_maxBlur;
+       newRect.ymax = input->ymax*DIVIDER + m_maxBlur;
+       newRect.xmin = input->xmin*DIVIDER - m_maxBlur;
+       newRect.xmax = input->xmax*DIVIDER + m_maxBlur;
        return NodeOperation::determineDependingAreaOfInterest(&newRect, readOperation, output);
 }
 #endif
index 0ecfb5a542c1e8c720e70d70182e6da499409dac..f283e60572e900fc438420e01c3eb12be964afae 100644 (file)
@@ -25,6 +25,7 @@
 #include "COM_NodeOperation.h"
 #include "COM_QualityStepHelper.h"
 
+//#define COM_DEFOCUS_SEARCH
 
 class VariableSizeBokehBlurOperation : public NodeOperation, public QualityStepHelper {
 private:
@@ -34,7 +35,7 @@ private:
        SocketReader *m_inputBokehProgram;
        SocketReader *m_inputSizeProgram;
 #ifdef COM_DEFOCUS_SEARCH
-       SocketReader *inputSearchProgram;
+       SocketReader *m_inputSearchProgram;
 #endif
 
 public:
@@ -71,10 +72,8 @@ public:
 #ifdef COM_DEFOCUS_SEARCH
 class InverseSearchRadiusOperation : public NodeOperation {
 private:
-       int maxBlur;
-       float threshold;
-       SocketReader *inputDepth;
-       SocketReader *inputRadius;
+       int m_maxBlur;
+       SocketReader *m_inputRadius;
 public:
        static const int DIVIDER = 4;
        
@@ -100,9 +99,7 @@ public:
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
        void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
        
-       void setMaxBlur(int maxRadius) { this->maxBlur = maxRadius; }
-
-       void setThreshold(float threshold) { this->threshold = threshold; }
+       void setMaxBlur(int maxRadius) { this->m_maxBlur = maxRadius; }
 };
 #endif
 #endif