diff options
Diffstat (limited to 'source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc')
| -rw-r--r-- | source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc | 1381 |
1 files changed, 1381 insertions, 0 deletions
diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc new file mode 100644 index 00000000000..b548a684ba5 --- /dev/null +++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cc @@ -0,0 +1,1381 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Copyright 2011, Blender Foundation. + */ + +#include <cstdlib> + +#include "BLI_math.h" +#include "COM_DoubleEdgeMaskOperation.h" +#include "DNA_node_types.h" +#include "MEM_guardedalloc.h" + +// this part has been copied from the double edge mask +static void do_adjacentKeepBorders(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize) +{ + int x; + unsigned int isz = 0; // inner edge size + unsigned int osz = 0; // outer edge size + unsigned int gsz = 0; // gradient fill area size + /* Test the four corners */ + /* upper left corner */ + x = t - rw + 1; + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* upper right corner */ + x = t; + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x - 1] && lomask[x - 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* lower left corner */ + x = 0; + // test if inner mask is filled + if (limask[x]) { + // test if pixel above, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* lower right corner */ + x = rw - 1; + // test if inner mask is filled + if (limask[x]) { + // test if pixel above, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x - 1] && lomask[x - 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + + /* Test the TOP row of pixels in buffer, except corners */ + for (x = t - 1; x >= (t - rw) + 2; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel to the right, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + /* Test the BOTTOM row of pixels in buffer, except corners */ + for (x = rw - 2; x; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel to the right, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + /* Test the LEFT edge of pixels in buffer, except corners */ + for (x = t - (rw << 1) + 1; x >= rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or above, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + /* Test the RIGHT edge of pixels in buffer, except corners */ + for (x = t - rw; x > rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or above, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + rsize[0] = isz; // fill in our return sizes for edges + fill + rsize[1] = osz; + rsize[2] = gsz; +} + +static void do_adjacentBleedBorders(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize) +{ + int x; + unsigned int isz = 0; // inner edge size + unsigned int osz = 0; // outer edge size + unsigned int gsz = 0; // gradient fill area size + /* Test the four corners */ + /* upper left corner */ + x = t - rw + 1; + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || + !lomask[x + 1]) { // test if outer mask is empty underneath or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* upper right corner */ + x = t; + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x - 1] && lomask[x - 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || + !lomask[x - 1]) { // test if outer mask is empty underneath or to the left + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* lower left corner */ + x = 0; + // test if inner mask is filled + if (limask[x]) { + // test if pixel above, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x + rw] || !lomask[x + 1]) { // test if outer mask is empty above or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* lower right corner */ + x = rw - 1; + // test if inner mask is filled + if (limask[x]) { + // test if pixel above, or to the left, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x - 1] && lomask[x - 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x + rw] || !lomask[x - 1]) { // test if outer mask is empty above or to the left + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* Test the TOP row of pixels in buffer, except corners */ + for (x = t - 1; x >= (t - rw) + 2; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel to the left, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - 1] || + !lomask[x + 1]) { // test if outer mask is empty to the left or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + /* Test the BOTTOM row of pixels in buffer, except corners */ + for (x = rw - 2; x; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel to the left, or to the right, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - 1] || + !lomask[x + 1]) { // test if outer mask is empty to the left or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + /* Test the LEFT edge of pixels in buffer, except corners */ + for (x = t - (rw << 1) + 1; x >= rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or above, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + /* Test the RIGHT edge of pixels in buffer, except corners */ + for (x = t - rw; x > rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if pixel underneath, or above, are empty in the inner mask, + // but filled in the outer mask + if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + rsize[0] = isz; // fill in our return sizes for edges + fill + rsize[1] = osz; + rsize[2] = gsz; +} + +static void do_allKeepBorders(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize) +{ + int x; + unsigned int isz = 0; // inner edge size + unsigned int osz = 0; // outer edge size + unsigned int gsz = 0; // gradient fill area size + /* Test the four corners */ + /* upper left corner */ + x = t - rw + 1; + // test if inner mask is filled + if (limask[x]) { + // test if the inner mask is empty underneath or to the right + if (!limask[x - rw] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* upper right corner */ + x = t; + // test if inner mask is filled + if (limask[x]) { + // test if the inner mask is empty underneath or to the left + if (!limask[x - rw] || !limask[x - 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* lower left corner */ + x = 0; + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty above or to the right + if (!limask[x + rw] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + /* lower right corner */ + x = rw - 1; + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty above or to the left + if (!limask[x + rw] || !limask[x - 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + + /* Test the TOP row of pixels in buffer, except corners */ + for (x = t - 1; x >= (t - rw) + 2; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty to the left or to the right + if (!limask[x - 1] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + /* Test the BOTTOM row of pixels in buffer, except corners */ + for (x = rw - 2; x; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty to the left or to the right + if (!limask[x - 1] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + /* Test the LEFT edge of pixels in buffer, except corners */ + for (x = t - (rw << 1) + 1; x >= rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty underneath or above + if (!limask[x - rw] || !limask[x + rw]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + /* Test the RIGHT edge of pixels in buffer, except corners */ + for (x = t - rw; x > rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty underneath or above + if (!limask[x - rw] || !limask[x + rw]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + } + + rsize[0] = isz; // fill in our return sizes for edges + fill + rsize[1] = osz; + rsize[2] = gsz; +} + +static void do_allBleedBorders(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize) +{ + int x; + unsigned int isz = 0; // inner edge size + unsigned int osz = 0; // outer edge size + unsigned int gsz = 0; // gradient fill area size + /* Test the four corners */ + /* upper left corner */ + x = t - rw + 1; + // test if inner mask is filled + if (limask[x]) { + // test if the inner mask is empty underneath or to the right + if (!limask[x - rw] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || + !lomask[x + 1]) { // test if outer mask is empty underneath or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* upper right corner */ + x = t; + // test if inner mask is filled + if (limask[x]) { + // test if the inner mask is empty underneath or to the left + if (!limask[x - rw] || !limask[x - 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || !lomask[x - 1]) { // test if outer mask is empty above or to the left + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* lower left corner */ + x = 0; + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty above or to the right + if (!limask[x + rw] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x + rw] || + !lomask[x + 1]) { // test if outer mask is empty underneath or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* lower right corner */ + x = rw - 1; + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty above or to the left + if (!limask[x + rw] || !limask[x - 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x + rw] || + !lomask[x - 1]) { // test if outer mask is empty underneath or to the left + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + /* Test the TOP row of pixels in buffer, except corners */ + for (x = t - 1; x >= (t - rw) + 2; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty to the left or to the right + if (!limask[x - 1] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - 1] || + !lomask[x + 1]) { // test if outer mask is empty to the left or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + /* Test the BOTTOM row of pixels in buffer, except corners */ + for (x = rw - 2; x; x--) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty to the left or to the right + if (!limask[x - 1] || !limask[x + 1]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - 1] || + !lomask[x + 1]) { // test if outer mask is empty to the left or to the right + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + /* Test the LEFT edge of pixels in buffer, except corners */ + for (x = t - (rw << 1) + 1; x >= rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty underneath or above + if (!limask[x - rw] || !limask[x + rw]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + /* Test the RIGHT edge of pixels in buffer, except corners */ + for (x = t - rw; x > rw; x -= rw) { + // test if inner mask is filled + if (limask[x]) { + // test if inner mask is empty underneath or above + if (!limask[x - rw] || !limask[x + rw]) { + isz++; // increment inner edge size + lres[x] = 4; // flag pixel as inner edge + } + else { + res[x] = 1.0f; // pixel is just part of inner mask, and it's not an edge + } + } + else if (lomask[x]) { // inner mask was empty, test if outer mask is filled + if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above + osz++; // increment outer edge size + lres[x] = 3; // flag pixel as outer edge + } + else { + gsz++; // increment the gradient pixel count + lres[x] = 2; // flag pixel as gradient + } + } + } + + rsize[0] = isz; // fill in our return sizes for edges + fill + rsize[1] = osz; + rsize[2] = gsz; +} + +static void do_allEdgeDetection(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize, + unsigned int in_isz, + unsigned int in_osz, + unsigned int in_gsz) +{ + int x; // x = pixel loop counter + int a; // a = pixel loop counter + int dx; // dx = delta x + int pix_prevRow; // pix_prevRow = pixel one row behind the one we are testing in a loop + int pix_nextRow; // pix_nextRow = pixel one row in front of the one we are testing in a loop + int pix_prevCol; // pix_prevCol = pixel one column behind the one we are testing in a loop + int pix_nextCol; // pix_nextCol = pixel one column in front of the one we are testing in a loop + /* Test all rows between the FIRST and LAST rows, excluding left and right edges */ + for (x = (t - rw) + 1, dx = x - (rw - 2); dx > rw; x -= rw, dx -= rw) { + a = x - 2; + pix_prevRow = a + rw; + pix_nextRow = a - rw; + pix_prevCol = a + 1; + pix_nextCol = a - 1; + while (a > dx - 2) { + if (!limask[a]) { // if the inner mask is empty + if (lomask[a]) { // if the outer mask is full + /* + * Next we test all 4 directions around the current pixel: next/prev/up/down + * The test ensures that the outer mask is empty and that the inner mask + * is also empty. If both conditions are true for any one of the 4 adjacent pixels + * then the current pixel is counted as being a true outer edge pixel. + */ + if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) || + (!lomask[pix_prevCol] && !limask[pix_prevCol]) || + (!lomask[pix_nextRow] && !limask[pix_nextRow]) || + (!lomask[pix_prevRow] && !limask[pix_prevRow])) { + in_osz++; // increment the outer boundary pixel count + lres[a] = 3; // flag pixel as part of outer edge + } + else { // it's not a boundary pixel, but it is a gradient pixel + in_gsz++; // increment the gradient pixel count + lres[a] = 2; // flag pixel as gradient + } + } + } + else { + if (!limask[pix_nextCol] || !limask[pix_prevCol] || !limask[pix_nextRow] || + !limask[pix_prevRow]) { + in_isz++; // increment the inner boundary pixel count + lres[a] = 4; // flag pixel as part of inner edge + } + else { + res[a] = 1.0f; // pixel is part of inner mask, but not at an edge + } + } + a--; + pix_prevRow--; + pix_nextRow--; + pix_prevCol--; + pix_nextCol--; + } + } + + rsize[0] = in_isz; // fill in our return sizes for edges + fill + rsize[1] = in_osz; + rsize[2] = in_gsz; +} + +static void do_adjacentEdgeDetection(unsigned int t, + unsigned int rw, + const unsigned int *limask, + const unsigned int *lomask, + unsigned int *lres, + float *res, + unsigned int *rsize, + unsigned int in_isz, + unsigned int in_osz, + unsigned int in_gsz) +{ + int x; // x = pixel loop counter + int a; // a = pixel loop counter + int dx; // dx = delta x + int pix_prevRow; // pix_prevRow = pixel one row behind the one we are testing in a loop + int pix_nextRow; // pix_nextRow = pixel one row in front of the one we are testing in a loop + int pix_prevCol; // pix_prevCol = pixel one column behind the one we are testing in a loop + int pix_nextCol; // pix_nextCol = pixel one column in front of the one we are testing in a loop + /* Test all rows between the FIRST and LAST rows, excluding left and right edges */ + for (x = (t - rw) + 1, dx = x - (rw - 2); dx > rw; x -= rw, dx -= rw) { + a = x - 2; + pix_prevRow = a + rw; + pix_nextRow = a - rw; + pix_prevCol = a + 1; + pix_nextCol = a - 1; + while (a > dx - 2) { + if (!limask[a]) { // if the inner mask is empty + if (lomask[a]) { // if the outer mask is full + /* + * Next we test all 4 directions around the current pixel: next/prev/up/down + * The test ensures that the outer mask is empty and that the inner mask + * is also empty. If both conditions are true for any one of the 4 adjacent pixels + * then the current pixel is counted as being a true outer edge pixel. + */ + if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) || + (!lomask[pix_prevCol] && !limask[pix_prevCol]) || + (!lomask[pix_nextRow] && !limask[pix_nextRow]) || + (!lomask[pix_prevRow] && !limask[pix_prevRow])) { + in_osz++; // increment the outer boundary pixel count + lres[a] = 3; // flag pixel as part of outer edge + } + else { // it's not a boundary pixel, but it is a gradient pixel + in_gsz++; // increment the gradient pixel count + lres[a] = 2; // flag pixel as gradient + } + } + } + else { + if ((!limask[pix_nextCol] && lomask[pix_nextCol]) || + (!limask[pix_prevCol] && lomask[pix_prevCol]) || + (!limask[pix_nextRow] && lomask[pix_nextRow]) || + (!limask[pix_prevRow] && lomask[pix_prevRow])) { + in_isz++; // increment the inner boundary pixel count + lres[a] = 4; // flag pixel as part of inner edge + } + else { + res[a] = 1.0f; // pixel is part of inner mask, but not at an edge + } + } + a--; + pix_prevRow--; // advance all four "surrounding" pixel pointers + pix_nextRow--; + pix_prevCol--; + pix_nextCol--; + } + } + + rsize[0] = in_isz; // fill in our return sizes for edges + fill + rsize[1] = in_osz; + rsize[2] = in_gsz; +} + +static void do_createEdgeLocationBuffer(unsigned int t, + unsigned int rw, + const unsigned int *lres, + float *res, + unsigned short *gbuf, + unsigned int *innerEdgeOffset, + unsigned int *outerEdgeOffset, + unsigned int isz, + unsigned int gsz) +{ + int x; // x = pixel loop counter + int a; // a = temporary pixel index buffer loop counter + unsigned int ud; // ud = unscaled edge distance + unsigned int dmin; // dmin = minimum edge distance + + unsigned int rsl; // long used for finding fast 1.0/sqrt + unsigned int gradientFillOffset; + + /* For looping inner edge pixel indexes, represents current position from offset. */ + unsigned int innerAccum = 0; + /* For looping outer edge pixel indexes, represents current position from offset. */ + unsigned int outerAccum = 0; + /* For looping gradient pixel indexes, represents current position from offset. */ + unsigned int gradientAccum = 0; + + /* */ + /* clang-format off */ + /* + * Here we compute the size of buffer needed to hold (row,col) coordinates + * for each pixel previously determined to be either gradient, inner edge, + * or outer edge. + * + * Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even + * though gbuf[] is declared as (unsigned short *) (2 bytes) because we don't + * store the pixel indexes, we only store x,y location of pixel in buffer. + * + * This does make the assumption that x and y can fit in 16 unsigned bits + * so if Blender starts doing renders greater than 65536 in either direction + * this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes + * per flagged pixel. + * + * In general, the buffer on-screen: + * + * Example: 9 by 9 pixel block + * + * . = pixel non-white in both outer and inner mask + * o = pixel white in outer, but not inner mask, adjacent to "." pixel + * g = pixel white in outer, but not inner mask, not adjacent to "." pixel + * i = pixel white in inner mask, adjacent to "g" or "." pixel + * F = pixel white in inner mask, only adjacent to other pixels white in the inner mask + * + * + * ......... <----- pixel #80 + * ..oooo... + * .oggggo.. + * .oggiggo. + * .ogiFigo. + * .oggiggo. + * .oggggo.. + * ..oooo... + * pixel #00 -----> ......... + * + * gsz = 18 (18 "g" pixels above) + * isz = 4 (4 "i" pixels above) + * osz = 18 (18 "o" pixels above) + * + * + * The memory in gbuf[] after filling will look like this: + * + * gradientFillOffset (0 pixels) innerEdgeOffset (18 pixels) outerEdgeOffset (22 pixels) + * / / / + * / / / + * |X Y X Y X Y X Y > <X Y X Y > <X Y X Y X Y > <X Y X Y | <- (x,y) + * +--------------------------------> <----------------> <------------------------> <----------------+ + * |0 2 4 6 8 10 12 14 > ... <68 70 72 74 > ... <80 82 84 86 88 90 > ... <152 154 156 158 | <- bytes + * +--------------------------------> <----------------> <------------------------> <----------------+ + * |g0 g0 g1 g1 g2 g2 g3 g3 > <g17 g17 i0 i0 > <i2 i2 i3 i3 o0 o0 > <o16 o16 o17 o17 | <- pixel + * / / / + * / / / + * / / / + * +---------- gradientAccum (18) ---------+ +--- innerAccum (22) ---+ +--- outerAccum (40) ---+ + * + * + * Ultimately we do need the pixel's memory buffer index to set the output + * pixel color, but it's faster to reconstruct the memory buffer location + * each iteration of the final gradient calculation than it is to deconstruct + * a memory location into x,y pairs each round. + */ + /* clang-format on */ + + gradientFillOffset = 0; // since there are likely "more" of these, put it first. :) + *innerEdgeOffset = gradientFillOffset + gsz; // set start of inner edge indexes + *outerEdgeOffset = (*innerEdgeOffset) + isz; // set start of outer edge indexes + /* set the accumulators to correct positions */ // set up some accumulator variables for loops + gradientAccum = gradientFillOffset; // each accumulator variable starts at its respective + innerAccum = *innerEdgeOffset; // section's offset so when we start filling, each + outerAccum = *outerEdgeOffset; // section fills up its allocated space in gbuf + // uses dmin=row, rsl=col + for (x = 0, dmin = 0; x < t; x += rw, dmin++) { + for (rsl = 0; rsl < rw; rsl++) { + a = x + rsl; + if (lres[a] == 2) { // it is a gradient pixel flagged by 2 + ud = gradientAccum << 1; // double the index to reach correct unsigned short location + gbuf[ud] = dmin; // insert pixel's row into gradient pixel location buffer + gbuf[ud + 1] = rsl; // insert pixel's column into gradient pixel location buffer + gradientAccum++; // increment gradient index buffer pointer + } + else if (lres[a] == 3) { // it is an outer edge pixel flagged by 3 + ud = outerAccum << 1; // double the index to reach correct unsigned short location + gbuf[ud] = dmin; // insert pixel's row into outer edge pixel location buffer + gbuf[ud + 1] = rsl; // insert pixel's column into outer edge pixel location buffer + outerAccum++; // increment outer edge index buffer pointer + res[a] = 0.0f; // set output pixel intensity now since it won't change later + } + else if (lres[a] == 4) { // it is an inner edge pixel flagged by 4 + ud = innerAccum << 1; // double int index to reach correct unsigned short location + gbuf[ud] = dmin; // insert pixel's row into inner edge pixel location buffer + gbuf[ud + 1] = rsl; // insert pixel's column into inner edge pixel location buffer + innerAccum++; // increment inner edge index buffer pointer + res[a] = 1.0f; // set output pixel intensity now since it won't change later + } + } + } +} + +static void do_fillGradientBuffer(unsigned int rw, + float *res, + const unsigned short *gbuf, + unsigned int isz, + unsigned int osz, + unsigned int gsz, + unsigned int innerEdgeOffset, + unsigned int outerEdgeOffset) +{ + int x; // x = pixel loop counter + int a; // a = temporary pixel index buffer loop counter + int fsz; // size of the frame + unsigned int rsl; // long used for finding fast 1.0/sqrt + float rsf; // float used for finding fast 1.0/sqrt + const float rsopf = 1.5f; // constant float used for finding fast 1.0/sqrt + + unsigned int gradientFillOffset; + unsigned int t; + unsigned int ud; // ud = unscaled edge distance + unsigned int dmin; // dmin = minimum edge distance + float odist; // odist = current outer edge distance + float idist; // idist = current inner edge distance + int dx; // dx = X-delta (used for distance proportion calculation) + int dy; // dy = Y-delta (used for distance proportion calculation) + + /* + * The general algorithm used to color each gradient pixel is: + * + * 1.) Loop through all gradient pixels. + * A.) For each gradient pixel: + * a.) Loop through all outside edge pixels, looking for closest one + * to the gradient pixel we are in. + * b.) Loop through all inside edge pixels, looking for closest one + * to the gradient pixel we are in. + * c.) Find proportion of distance from gradient pixel to inside edge + * pixel compared to sum of distance to inside edge and distance to + * outside edge. + * + * In an image where: + * . = blank (black) pixels, not covered by inner mask or outer mask + * + = desired gradient pixels, covered only by outer mask + * * = white full mask pixels, covered by at least inner mask + * + * ............................... + * ...............+++++++++++..... + * ...+O++++++..++++++++++++++.... + * ..+++\++++++++++++++++++++..... + * .+++++G+++++++++*******+++..... + * .+++++|+++++++*********+++..... + * .++***I****************+++..... + * .++*******************+++...... + * .+++*****************+++....... + * ..+++***************+++........ + * ....+++**********+++........... + * ......++++++++++++............. + * ............................... + * + * O = outside edge pixel + * \ + * G = gradient pixel + * | + * I = inside edge pixel + * + * __ + * *note that IO does not need to be a straight line, in fact + * many cases can arise where straight lines do not work + * correctly. + * + * __ __ __ + * d.) Pixel color is assigned as |GO| / ( |GI| + |GO| ) + * + * The implementation does not compute distance, but the reciprocal of the + * distance. This is done to avoid having to compute a square root, as a + * reciprocal square root can be computed faster. Therefore, the code computes + * pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the + * purpose of GO for the proportion calculation. + * + * For the purposes of the minimum distance comparisons, we only check + * the sums-of-squares against each other, since they are in the same + * mathematical sort-order as if we did go ahead and take square roots + * + * Loop through all gradient pixels. + */ + + for (x = gsz - 1; x >= 0; x--) { + gradientFillOffset = x << 1; + t = gbuf[gradientFillOffset]; // calculate column of pixel indexed by gbuf[x] + fsz = gbuf[gradientFillOffset + 1]; // calculate row of pixel indexed by gbuf[x] + dmin = 0xffffffff; // reset min distance to edge pixel + for (a = outerEdgeOffset + osz - 1; a >= outerEdgeOffset; + a--) { // loop through all outer edge buffer pixels + ud = a << 1; + dy = t - gbuf[ud]; // set dx to gradient pixel column - outer edge pixel row + dx = fsz - gbuf[ud + 1]; // set dy to gradient pixel row - outer edge pixel column + ud = dx * dx + dy * dy; // compute sum of squares + if (ud < dmin) { // if our new sum of squares is less than the current minimum + dmin = ud; // set a new minimum equal to the new lower value + } + } + odist = (float)(dmin); // cast outer min to a float + rsf = odist * 0.5f; // + rsl = *(unsigned int *)&odist; // use some peculiar properties of the way bits are stored + rsl = 0x5f3759df - (rsl >> 1); // in floats vs. unsigned ints to compute an approximate + odist = *(float *)&rsl; // reciprocal square root + odist = odist * (rsopf - (rsf * odist * + odist)); // -- ** this line can be iterated for more accuracy ** -- + dmin = 0xffffffff; // reset min distance to edge pixel + for (a = innerEdgeOffset + isz - 1; a >= innerEdgeOffset; + a--) { // loop through all inside edge pixels + ud = a << 1; + dy = t - gbuf[ud]; // compute delta in Y from gradient pixel to inside edge pixel + dx = fsz - gbuf[ud + 1]; // compute delta in X from gradient pixel to inside edge pixel + ud = dx * dx + dy * dy; // compute sum of squares + if (ud < dmin) { // if our new sum of squares is less than the current minimum we've found + dmin = ud; // set a new minimum equal to the new lower value + } + } + idist = (float)(dmin); // cast inner min to a float + rsf = idist * 0.5f; // + rsl = *(unsigned int *)&idist; // + rsl = 0x5f3759df - (rsl >> 1); // see notes above + idist = *(float *)&rsl; // + idist = idist * (rsopf - (rsf * idist * idist)); // + /* + * Note once again that since we are using reciprocals of distance values our + * proportion is already the correct intensity, and does not need to be + * subtracted from 1.0 like it would have if we used real distances. + */ + + /* + * Here we reconstruct the pixel's memory location in the CompBuf by + * Pixel Index = Pixel Column + ( Pixel Row * Row Width ) + */ + res[gbuf[gradientFillOffset + 1] + (gbuf[gradientFillOffset] * rw)] = + (idist / (idist + odist)); // set intensity + } +} + +// end of copy + +void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float *res) +{ + unsigned int *lres; // lres = unsigned int pointer to output pixel buffer (for bit operations) + unsigned int *limask; // limask = unsigned int pointer to inner mask (for bit operations) + unsigned int *lomask; // lomask = unsigned int pointer to outer mask (for bit operations) + + int rw; // rw = pixel row width + int t; // t = total number of pixels in buffer - 1 (used for loop starts) + int fsz; // size of the frame + + unsigned int isz = 0; // size (in pixels) of inside edge pixel index buffer + unsigned int osz = 0; // size (in pixels) of outside edge pixel index buffer + unsigned int gsz = 0; // size (in pixels) of gradient pixel index buffer + unsigned int rsize[3]; // size storage to pass to helper functions + unsigned int innerEdgeOffset = + 0; // offset into final buffer where inner edge pixel indexes start + unsigned int outerEdgeOffset = + 0; // offset into final buffer where outer edge pixel indexes start + + unsigned short *gbuf; // gradient/inner/outer pixel location index buffer + + if (true) { // if both input sockets have some data coming in... + + rw = this->getWidth(); // width of a row of pixels + t = (rw * this->getHeight()) - 1; // determine size of the frame + memset(res, + 0, + sizeof(float) * (t + 1)); // clear output buffer (not all pixels will be written later) + + lres = (unsigned int *)res; // unsigned int pointer to output buffer (for bit level ops) + limask = (unsigned int *)imask; // unsigned int pointer to input mask (for bit level ops) + lomask = (unsigned int *)omask; // unsigned int pointer to output mask (for bit level ops) + + /* + * The whole buffer is broken up into 4 parts. The four CORNERS, the FIRST and LAST rows, the + * LEFT and RIGHT edges (excluding the corner pixels), and all OTHER rows. + * This allows for quick computation of outer edge pixels where + * a screen edge pixel is marked to be gradient. + * + * The pixel type (gradient vs inner-edge vs outer-edge) tests change + * depending on the user selected "Inner Edge Mode" and the user selected + * "Buffer Edge Mode" on the node's GUI. There are 4 sets of basically the + * same algorithm: + * + * 1.) Inner Edge -> Adjacent Only + * Buffer Edge -> Keep Inside + * + * 2.) Inner Edge -> Adjacent Only + * Buffer Edge -> Bleed Out + * + * 3.) Inner Edge -> All + * Buffer Edge -> Keep Inside + * + * 4.) Inner Edge -> All + * Buffer Edge -> Bleed Out + * + * Each version has slightly different criteria for detecting an edge pixel. + */ + if (this->m_adjacentOnly) { // if "adjacent only" inner edge mode is turned on + if (this->m_keepInside) { // if "keep inside" buffer edge mode is turned on + do_adjacentKeepBorders(t, rw, limask, lomask, lres, res, rsize); + } + else { // "bleed out" buffer edge mode is turned on + do_adjacentBleedBorders(t, rw, limask, lomask, lres, res, rsize); + } + // set up inner edge, outer edge, and gradient buffer sizes after border pass + isz = rsize[0]; + osz = rsize[1]; + gsz = rsize[2]; + // detect edges in all non-border pixels in the buffer + do_adjacentEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz); + } + else { // "all" inner edge mode is turned on + if (this->m_keepInside) { // if "keep inside" buffer edge mode is turned on + do_allKeepBorders(t, rw, limask, lomask, lres, res, rsize); + } + else { // "bleed out" buffer edge mode is turned on + do_allBleedBorders(t, rw, limask, lomask, lres, res, rsize); + } + // set up inner edge, outer edge, and gradient buffer sizes after border pass + isz = rsize[0]; + osz = rsize[1]; + gsz = rsize[2]; + // detect edges in all non-border pixels in the buffer + do_allEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz); + } + + // set edge and gradient buffer sizes once again... + // the sizes in rsize[] may have been modified + // by the do_*EdgeDetection() function. + isz = rsize[0]; + osz = rsize[1]; + gsz = rsize[2]; + + // calculate size of pixel index buffer needed + fsz = gsz + isz + osz; + // allocate edge/gradient pixel index buffer + gbuf = (unsigned short *)MEM_callocN(sizeof(unsigned short) * fsz * 2, "DEM"); + + do_createEdgeLocationBuffer( + t, rw, lres, res, gbuf, &innerEdgeOffset, &outerEdgeOffset, isz, gsz); + do_fillGradientBuffer(rw, res, gbuf, isz, osz, gsz, innerEdgeOffset, outerEdgeOffset); + + // free the gradient index buffer + MEM_freeN(gbuf); + } +} + +DoubleEdgeMaskOperation::DoubleEdgeMaskOperation() +{ + this->addInputSocket(COM_DT_VALUE); + this->addInputSocket(COM_DT_VALUE); + this->addOutputSocket(COM_DT_VALUE); + this->m_inputInnerMask = nullptr; + this->m_inputOuterMask = nullptr; + this->m_adjacentOnly = false; + this->m_keepInside = false; + this->setComplex(true); +} + +bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti * /*input*/, + ReadBufferOperation *readOperation, + rcti *output) +{ + if (this->m_cachedInstance == nullptr) { + rcti newInput; + newInput.xmax = this->getWidth(); + newInput.xmin = 0; + newInput.ymax = this->getHeight(); + newInput.ymin = 0; + return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + } + + return false; +} + +void DoubleEdgeMaskOperation::initExecution() +{ + this->m_inputInnerMask = this->getInputSocketReader(0); + this->m_inputOuterMask = this->getInputSocketReader(1); + initMutex(); + this->m_cachedInstance = nullptr; +} + +void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect) +{ + if (this->m_cachedInstance) { + return this->m_cachedInstance; + } + + lockMutex(); + if (this->m_cachedInstance == nullptr) { + MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect); + MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect); + float *data = (float *)MEM_mallocN(sizeof(float) * this->getWidth() * this->getHeight(), + __func__); + float *imask = innerMask->getBuffer(); + float *omask = outerMask->getBuffer(); + doDoubleEdgeMask(imask, omask, data); + this->m_cachedInstance = data; + } + unlockMutex(); + return this->m_cachedInstance; +} +void DoubleEdgeMaskOperation::executePixel(float output[4], int x, int y, void *data) +{ + float *buffer = (float *)data; + int index = (y * this->getWidth() + x); + output[0] = buffer[index]; +} + +void DoubleEdgeMaskOperation::deinitExecution() +{ + this->m_inputInnerMask = nullptr; + this->m_inputOuterMask = nullptr; + deinitMutex(); + if (this->m_cachedInstance) { + MEM_freeN(this->m_cachedInstance); + this->m_cachedInstance = nullptr; + } +} |