minor optimizations for dilate
authorCampbell Barton <ideasman42@gmail.com>
Fri, 15 Jun 2012 15:55:37 +0000 (15:55 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 15 Jun 2012 15:55:37 +0000 (15:55 +0000)
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_OpenCLKernels.cl
source/blender/nodes/composite/nodes/node_composite_dilate.c

index 17b0430..f6d794f 100644 (file)
@@ -82,11 +82,11 @@ void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, Mem
        this->inputProgram->read(inputValue, x, y, inputBuffers, NULL);
        if (inputValue[0] > sw) {
                for (int yi = miny; yi < maxy; yi++) {
+                       const float dy = yi - y;
                        offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
                        for (int xi = minx; xi < maxx; xi++) {
                                if (buffer[offset] < sw) {
                                        const float dx = xi - x;
-                                       const float dy = yi - y;
                                        const float dis = dx * dx + dy * dy;
                                        mindist = min(mindist, dis);
                                }
@@ -97,11 +97,11 @@ void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, Mem
        }
        else {
                for (int yi = miny; yi < maxy; yi++) {
+                       const float dy = yi - y;
                        offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
                        for (int xi = minx; xi < maxx; xi++) {
                                if (buffer[offset] > sw) {
                                        const float dx = xi - x;
-                                       const float dy = yi - y;
                                        const float dis = dx * dx + dy * dy;
                                        mindist = min(mindist, dis);
                                }
@@ -187,7 +187,7 @@ void *DilateDistanceOperation::initializeTileData(rcti *rect, MemoryBuffer **mem
 void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
        const float distance = this->distance;
-       float mindist = distance * distance;
+       const float mindist = distance * distance;
 
        MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
        float *buffer = inputBuffer->getBuffer();
@@ -202,10 +202,10 @@ void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuf
        float value = 0.0f;
 
        for (int yi = miny; yi < maxy; yi++) {
+               const float dy = yi - y;
                offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
                for (int xi = minx; xi < maxx; xi++) {
                        const float dx = xi - x;
-                       const float dy = yi - y;
                        const float dis = dx * dx + dy * dy;
                        if (dis <= mindist) {
                                value = max(buffer[offset], value);
@@ -262,7 +262,7 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation()
 void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
        const float distance = this->distance;
-       float mindist = distance * distance;
+       const float mindist = distance * distance;
 
        MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
        float *buffer = inputBuffer->getBuffer();
@@ -277,10 +277,10 @@ void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuff
        float value = 1.0f;
 
        for (int yi = miny; yi < maxy; yi++) {
+               const float dy = yi - y;
                offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
                for (int xi = minx; xi < maxx; xi++) {
                        const float dx = xi - x;
-                       const float dy = yi - y;
                        const float dis = dx * dx + dy * dy;
                        if (dis <= mindist) {
                                value = min(buffer[offset], value);
index e1f175b..0f8e543 100644 (file)
@@ -68,9 +68,9 @@ __kernel void dilateKernel(__read_only image2d_t inputImage,  __write_only image
        int2 inputXy;
        
        for (ny = minXY.y, inputXy.y = ny - offsetInput.y ; ny < maxXY.y ; ny ++, inputXy.y++) {
+               const float deltaY = (realCoordinate.y - ny);
                for (nx = minXY.x, inputXy.x = nx - offsetInput.x; nx < maxXY.x ; nx ++, inputXy.x++) {
                        const float deltaX = (realCoordinate.x - nx);
-                       const float deltaY = (realCoordinate.y - ny);
                        const float measuredDistance = deltaX*deltaX+deltaY*deltaY;
                        if (measuredDistance <= distanceSquared) {
                                value = max(value, read_imagef(inputImage, SAMPLER_NEAREST, inputXy).s0);
index ec7aacc..2f13983 100644 (file)
@@ -52,28 +52,28 @@ static void morpho_dilate(CompBuf *cbuf)
        for (y = 0; y < cbuf->y; y++) {
                for (x = 0; x < cbuf->x - 1; x++) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MAX2(*p, *(p + 1));
+                       *p = maxf(*p, *(p + 1));
                }
        }
 
        for (y = 0; y < cbuf->y; y++) {
                for (x = cbuf->x - 1; x >= 1; x--) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MAX2(*p, *(p - 1));
+                       *p = maxf(*p, *(p - 1));
                }
        }
 
        for (x = 0; x < cbuf->x; x++) {
                for (y = 0; y < cbuf->y - 1; y++) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MAX2(*p, *(p + cbuf->x));
+                       *p = maxf(*p, *(p + cbuf->x));
                }
        }
 
        for (x = 0; x < cbuf->x; x++) {
                for (y = cbuf->y - 1; y >= 1; y--) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MAX2(*p, *(p - cbuf->x));
+                       *p = maxf(*p, *(p - cbuf->x));
                }
        }
 }
@@ -86,28 +86,28 @@ static void morpho_erode(CompBuf *cbuf)
        for (y = 0; y < cbuf->y; y++) {
                for (x = 0; x < cbuf->x - 1; x++) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MIN2(*p, *(p + 1));
+                       *p = minf(*p, *(p + 1));
                }
        }
 
        for (y = 0; y < cbuf->y; y++) {
                for (x = cbuf->x - 1; x >= 1; x--) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MIN2(*p, *(p - 1));
+                       *p = minf(*p, *(p - 1));
                }
        }
 
        for (x = 0; x < cbuf->x; x++) {
                for (y = 0; y < cbuf->y - 1; y++) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MIN2(*p, *(p + cbuf->x));
+                       *p = minf(*p, *(p + cbuf->x));
                }
        }
 
        for (x = 0; x < cbuf->x; x++) {
                for (y = cbuf->y - 1; y >= 1; y--) {
                        p = rectf + cbuf->x * y + x;
-                       *p = MIN2(*p, *(p - cbuf->x));
+                       *p = minf(*p, *(p - cbuf->x));
                }
        }
        
@@ -122,8 +122,7 @@ static void node_composit_exec_dilateerode(void *UNUSED(data), bNode *node, bNod
        
        /* input no image? then only color operation */
        if (in[0]->data == NULL) {
-               out[0]->vec[0] = out[0]->vec[1] = out[0]->vec[2] = 0.0f;
-               out[0]->vec[3] = 0.0f;
+               zero_v4(out[0]->vec);
        }
        else {
                /* make output size of input image */