From 2b8ac9bc616d9a9cd8f303228efc30fdc9dd38a1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Mon, 6 Aug 2012 13:45:11 +0000 Subject: inpaint node from tomato branch by Peter Schlaile http://en.wikipedia.org/wiki/Inpainting --- source/blender/blenkernel/BKE_node.h | 1 + source/blender/blenkernel/intern/node.c | 1 + source/blender/compositor/CMakeLists.txt | 4 + source/blender/compositor/intern/COM_Converter.cpp | 4 + .../blender/compositor/nodes/COM_InpaintNode.cpp | 48 ++++ source/blender/compositor/nodes/COM_InpaintNode.h | 38 +++ .../compositor/operations/COM_InpaintOperation.cpp | 305 +++++++++++++++++++++ .../compositor/operations/COM_InpaintOperation.h | 76 +++++ source/blender/editors/space_node/drawnode.c | 8 + source/blender/makesdna/DNA_node_types.h | 4 + source/blender/makesrna/intern/rna_nodetree.c | 20 ++ .../blender/makesrna/intern/rna_nodetree_types.h | 1 + source/blender/nodes/CMakeLists.txt | 1 + source/blender/nodes/NOD_composite.h | 1 + .../nodes/composite/nodes/node_composite_inpaint.c | 61 +++++ 15 files changed, 573 insertions(+) create mode 100644 source/blender/compositor/nodes/COM_InpaintNode.cpp create mode 100644 source/blender/compositor/nodes/COM_InpaintNode.h create mode 100644 source/blender/compositor/operations/COM_InpaintOperation.cpp create mode 100644 source/blender/compositor/operations/COM_InpaintOperation.h create mode 100644 source/blender/nodes/composite/nodes/node_composite_inpaint.c diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h index 0d867bbbb51..61845619452 100644 --- a/source/blender/blenkernel/BKE_node.h +++ b/source/blender/blenkernel/BKE_node.h @@ -671,6 +671,7 @@ void ntreeGPUMaterialNodes(struct bNodeTree *ntree, struct GPUMateria #define CMP_NODE_KEYINGSCREEN 269 #define CMP_NODE_KEYING 270 #define CMP_NODE_TRACKPOS 271 +#define CMP_NODE_INPAINT 272 #define CMP_NODE_GLARE 301 #define CMP_NODE_TONEMAP 302 diff --git a/source/blender/blenkernel/intern/node.c b/source/blender/blenkernel/intern/node.c index c600ab5ebea..8670f86cd67 100644 --- a/source/blender/blenkernel/intern/node.c +++ b/source/blender/blenkernel/intern/node.c @@ -1990,6 +1990,7 @@ static void registerCompositNodes(bNodeTreeType *ttype) register_node_type_cmp_bilateralblur(ttype); register_node_type_cmp_vecblur(ttype); register_node_type_cmp_dilateerode(ttype); + register_node_type_cmp_inpaint(ttype); register_node_type_cmp_defocus(ttype); register_node_type_cmp_valtorgb(ttype); diff --git a/source/blender/compositor/CMakeLists.txt b/source/blender/compositor/CMakeLists.txt index 870e379b343..4dc111cebd2 100644 --- a/source/blender/compositor/CMakeLists.txt +++ b/source/blender/compositor/CMakeLists.txt @@ -286,6 +286,8 @@ set(SRC nodes/COM_FilterNode.h nodes/COM_DilateErodeNode.cpp nodes/COM_DilateErodeNode.h + nodes/COM_InpaintNode.cpp + nodes/COM_InpaintNode.h nodes/COM_BlurNode.cpp nodes/COM_BlurNode.h nodes/COM_BokehBlurNode.cpp @@ -590,6 +592,8 @@ set(SRC operations/COM_ConvolutionEdgeFilterOperation.cpp operations/COM_DilateErodeOperation.cpp operations/COM_DilateErodeOperation.h + operations/COM_InpaintOperation.cpp + operations/COM_InpaintOperation.h operations/COM_GlareThresholdOperation.cpp operations/COM_GlareThresholdOperation.h operations/COM_GlareBaseOperation.cpp diff --git a/source/blender/compositor/intern/COM_Converter.cpp b/source/blender/compositor/intern/COM_Converter.cpp index 37d38261ea5..24c3c36b79e 100644 --- a/source/blender/compositor/intern/COM_Converter.cpp +++ b/source/blender/compositor/intern/COM_Converter.cpp @@ -74,6 +74,7 @@ #include "COM_HueSaturationValueNode.h" #include "COM_IDMaskNode.h" #include "COM_ImageNode.h" +#include "COM_InpaintNode.h" #include "COM_InvertNode.h" #include "COM_KeyingNode.h" #include "COM_KeyingScreenNode.h" @@ -303,6 +304,9 @@ Node *Converter::convert(bNode *b_node, bool fast) case CMP_NODE_DILATEERODE: node = new DilateErodeNode(b_node); break; + case CMP_NODE_INPAINT: + node = new InpaintNode(b_node); + break; case CMP_NODE_LENSDIST: node = new LensDistortionNode(b_node); break; diff --git a/source/blender/compositor/nodes/COM_InpaintNode.cpp b/source/blender/compositor/nodes/COM_InpaintNode.cpp new file mode 100644 index 00000000000..e90a3921edc --- /dev/null +++ b/source/blender/compositor/nodes/COM_InpaintNode.cpp @@ -0,0 +1,48 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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. + * + * Contributor: Peter Schlaile + * Jeroen Bakker + * Monique Dewanchand + */ + +#include "COM_InpaintNode.h" +#include "DNA_scene_types.h" +#include "COM_ExecutionSystem.h" +#include "COM_InpaintOperation.h" +#include "BLI_math.h" + +InpaintNode::InpaintNode(bNode *editorNode) : Node(editorNode) +{ + /* pass */ +} + +void InpaintNode::convertToOperations(ExecutionSystem *graph, CompositorContext *context) +{ + + bNode *editorNode = this->getbNode(); + + /* if (editorNode->custom1 == CMP_NODE_INPAINT_SIMPLE) { */ + if (true) { + InpaintSimpleOperation *operation = new InpaintSimpleOperation(); + operation->setbNode(editorNode); + operation->setIterations(editorNode->custom2); + this->getInputSocket(0)->relinkConnections(operation->getInputSocket(0), 0, graph); + this->getOutputSocket(0)->relinkConnections(operation->getOutputSocket(0)); + graph->addOperation(operation); + } +} diff --git a/source/blender/compositor/nodes/COM_InpaintNode.h b/source/blender/compositor/nodes/COM_InpaintNode.h new file mode 100644 index 00000000000..5837b979958 --- /dev/null +++ b/source/blender/compositor/nodes/COM_InpaintNode.h @@ -0,0 +1,38 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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. + * + * Contributor: Peter Schlaile + * Jeroen Bakker + * Monique Dewanchand + */ + +#ifndef _COM_InpaintNode_h_ +#define _COM_InpaintNode_h_ + +#include "COM_Node.h" + +/** + * @brief InpaintNode + * @ingroup Node + */ +class InpaintNode : public Node { +public: + InpaintNode(bNode *editorNode); + void convertToOperations(ExecutionSystem *graph, CompositorContext *context); +}; + +#endif diff --git a/source/blender/compositor/operations/COM_InpaintOperation.cpp b/source/blender/compositor/operations/COM_InpaintOperation.cpp new file mode 100644 index 00000000000..5b21273e4ab --- /dev/null +++ b/source/blender/compositor/operations/COM_InpaintOperation.cpp @@ -0,0 +1,305 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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. + * + * Contributor: Peter Schlaile + * Jeroen Bakker + * Monique Dewanchand + */ + +#include "MEM_guardedalloc.h" + +#include "COM_InpaintOperation.h" +#include "COM_OpenCLDevice.h" + +#include "BLI_math.h" + +#define ASSERT_XY_RANGE(x, y) \ + BLI_assert(x >= 0 && x < this->getWidth() && \ + y >= 0 && y < this->getHeight()) + + +// Inpaint (simple convolve using average of known pixels) +InpaintSimpleOperation::InpaintSimpleOperation() : NodeOperation() +{ + this->addInputSocket(COM_DT_COLOR); + this->addOutputSocket(COM_DT_COLOR); + this->setComplex(true); + this->m_inputImageProgram = NULL; + this->m_pixelorder = NULL; + this->m_manhatten_distance = NULL; + this->m_cached_buffer = NULL; + this->m_cached_buffer_ready = false; +} +void InpaintSimpleOperation::initExecution() +{ + this->m_inputImageProgram = this->getInputSocketReader(0); + + this->m_cached_buffer = NULL; + this->m_pixelorder = NULL; + this->m_manhatten_distance = NULL; + this->m_cached_buffer = NULL; + this->m_cached_buffer_ready = false; + + this->initMutex(); +} + +void InpaintSimpleOperation::clamp_xy(int & x, int & y) +{ + int width = this->getWidth(); + int height = this->getHeight(); + + if (x < 0) { + x = 0; + } + else if (x >= width) { + x = width - 1; + } + + if (y < 0) { + y = 0; + } + else if (y >= height) { + y = height - 1; + } +} + +float InpaintSimpleOperation::get(int x, int y, int component) +{ + int width = this->getWidth(); + + ASSERT_XY_RANGE(x, y); + + return this->m_cached_buffer[ + y * width * COM_NUMBER_OF_CHANNELS + + x * COM_NUMBER_OF_CHANNELS + component]; +} + +void InpaintSimpleOperation::set(int x, int y, int component, float v) +{ + int width = this->getWidth(); + + ASSERT_XY_RANGE(x, y); + + this->m_cached_buffer[ + y * width * COM_NUMBER_OF_CHANNELS + + x * COM_NUMBER_OF_CHANNELS + component] = v; +} + +int InpaintSimpleOperation::mdist(int x, int y) +{ + int width = this->getWidth(); + + ASSERT_XY_RANGE(x, y); + + return this->m_manhatten_distance[y * width + x]; +} + +bool InpaintSimpleOperation::next_pixel(int & x, int & y, int & curr, int iters) +{ + int width = this->getWidth(); + + if (curr >= this->m_area_size) { + return false; + } + + int r = this->m_pixelorder[curr++]; + + x = r % width; + y = r / width; + + if (mdist(x, y) > iters) { + return false; + } + + return true; +} + +void InpaintSimpleOperation::calc_manhatten_distance() +{ + int width = this->getWidth(); + int height = this->getHeight(); + short *m = this->m_manhatten_distance = new short[width * height]; + int *offsets; + + offsets = (int *)MEM_callocN(sizeof(int) * (width + height + 1), "InpaintSimpleOperation offsets"); + + for (int j = 0; j < height; j++) { + for (int i = 0; i < width; i++) { + int r = 0; + /* no need to clamp here */ + if (get(i, j, 3) < 1.0f) { + r = width + height; + if (i > 0) + r = mini(r, m[j * width + i - 1] + 1); + if (j > 0) + r = mini(r, m[(j - 1) * width + i] + 1); + } + m[j * width + i] = r; + } + } + + for (int j = height - 1; j >= 0; j--) { + for (int i = width; i >= 0; i--) { + int r = m[j * width + i]; + + if (i + 1 < width) + r = mini(r, m[j * width + i + 1] + 1); + if (j + 1 < height) + r = mini(r, m[(j + 1) * width + i] + 1); + + m[j * width + i] = r; + + offsets[r]++; + } + } + + offsets[0] = 0; + + for (int i = 1; i < width + height + 1; i++) { + offsets[i] += offsets[i - 1]; + } + + this->m_area_size = offsets[width + height]; + this->m_pixelorder = new int[this->m_area_size]; + + for (int i = 0; i < width * height; i++) { + if (m[i] > 0) { + this->m_pixelorder[offsets[m[i] - 1]++] = i; + } + } + + MEM_freeN(offsets); +} + +void InpaintSimpleOperation::pix_step(int x, int y) +{ + int d = this->mdist(x, y); + + float n = 0; + + float pix[3] = {0.0f, 0.0f, 0.0f}; + + for (int dx = -1; dx <= 1; dx++) { + for (int dy = -1; dy <= 1; dy++) { + if (dx != 0 && dy != 0) { + + int x_ofs = x + dx; + int y_ofs = y + dy; + clamp_xy(x_ofs, y_ofs); + + if (this->mdist(x_ofs, y_ofs) < d) { + + float weight; + + if (dx == 0 || dy == 0) { + weight = 1.0f; + } + else { + weight = M_SQRT1_2; /* 1.0f / sqrt(2) */ + } + + for (int c = 0; c < 3; c++) { + float fk = this->get(x_ofs, y_ofs, c); + + pix[c] += fk * weight; + } + n += weight; + } + } + } + } + + for (int c = 0; c < 3; c++) { + this->set(x, y, c, pix[c] / n); + } +} + +void *InpaintSimpleOperation::initializeTileData(rcti *rect) +{ + if (this->m_cached_buffer_ready) { + return this->m_cached_buffer; + } + lockMutex(); + if (!this->m_cached_buffer_ready) { + MemoryBuffer *buf = (MemoryBuffer *)this->m_inputImageProgram->initializeTileData(rect); + + this->m_cached_buffer = new float[this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS]; + memcpy(this->m_cached_buffer, buf->getBuffer(), this->getWidth() * this->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float)); + + calc_manhatten_distance(); + + int curr = 0; + int x, y; + + + while (next_pixel(x, y, curr, this->m_iterations)) { + pix_step(x, y); + } + this->m_cached_buffer_ready = true; + } + + unlockMutex(); + return this->m_cached_buffer; +} + +void InpaintSimpleOperation::executePixel(float *color, int x, int y, void *data) +{ + clamp_xy(x, y); + for (int c = 0; c < 3; c++) { + color[c] = get(x, y, c); + } + color[3] = 1.0f; +} + +void InpaintSimpleOperation::deinitExecution() +{ + this->m_inputImageProgram = NULL; + this->deinitMutex(); + if (this->m_cached_buffer) { + delete [] this->m_cached_buffer; + this->m_cached_buffer = NULL; + } + + if (this->m_pixelorder) { + delete [] this->m_pixelorder; + this->m_pixelorder = NULL; + } + + if (this->m_manhatten_distance) { + delete [] this->m_manhatten_distance; + this->m_manhatten_distance = NULL; + } + this->m_cached_buffer_ready = false; +} + +bool InpaintSimpleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output) +{ + if (this->m_cached_buffer_ready) { + return false; + } + else { + rcti newInput; + + newInput.xmax = getWidth(); + newInput.xmin = 0; + newInput.ymax = getHeight(); + newInput.ymin = 0; + + return NodeOperation::determineDependingAreaOfInterest(&newInput, readOperation, output); + } +} + diff --git a/source/blender/compositor/operations/COM_InpaintOperation.h b/source/blender/compositor/operations/COM_InpaintOperation.h new file mode 100644 index 00000000000..0ff65174161 --- /dev/null +++ b/source/blender/compositor/operations/COM_InpaintOperation.h @@ -0,0 +1,76 @@ +/* + * Copyright 2011, Blender Foundation. + * + * 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. + * + * Contributor: Peter Schlaile + * Jeroen Bakker + * Monique Dewanchand + */ + +#ifndef _COM_InpaintOperation_h +#define _COM_InpaintOperation_h +#include "COM_NodeOperation.h" + +class InpaintSimpleOperation : public NodeOperation { +protected: + /** + * Cached reference to the inputProgram + */ + SocketReader *m_inputImageProgram; + + int m_iterations; + + float *m_cached_buffer; + bool m_cached_buffer_ready; + + int *m_pixelorder; + int m_area_size; + short *m_manhatten_distance; +public: + InpaintSimpleOperation(); + + /** + * the inner loop of this program + */ + void executePixel(float *color, int x, int y, void *data); + + /** + * Initialize the execution + */ + void initExecution(); + + void *initializeTileData(rcti *rect); + /** + * Deinitialize the execution + */ + void deinitExecution(); + + void setIterations(int iterations) { this->m_iterations = iterations; } + + bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); + +private: + void calc_manhatten_distance(); + void clamp_xy(int & x, int & y); + float get(int x, int y, int component); + void set(int x, int y, int component, float v); + int mdist(int x, int y); + bool next_pixel(int & x, int & y, int & curr, int iters); + void pix_step(int x, int y); +}; + + +#endif diff --git a/source/blender/editors/space_node/drawnode.c b/source/blender/editors/space_node/drawnode.c index de882bd3635..3e34c369a69 100644 --- a/source/blender/editors/space_node/drawnode.c +++ b/source/blender/editors/space_node/drawnode.c @@ -1807,6 +1807,11 @@ static void node_composit_buts_dilateerode(uiLayout *layout, bContext *UNUSED(C) } } +static void node_composit_buts_inpaint(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) +{ + uiItemR(layout, ptr, "distance", 0, NULL, ICON_NONE); +} + static void node_composit_buts_diff_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) { uiLayout *col; @@ -2659,6 +2664,9 @@ static void node_composit_set_butfunc(bNodeType *ntype) case CMP_NODE_DILATEERODE: ntype->uifunc = node_composit_buts_dilateerode; break; + case CMP_NODE_INPAINT: + ntype->uifunc = node_composit_buts_inpaint; + break; case CMP_NODE_OUTPUT_FILE: ntype->uifunc = node_composit_buts_file_output; ntype->uifuncbut = node_composit_buts_file_output_details; diff --git a/source/blender/makesdna/DNA_node_types.h b/source/blender/makesdna/DNA_node_types.h index 731f44d2564..d0c2a5c9925 100644 --- a/source/blender/makesdna/DNA_node_types.h +++ b/source/blender/makesdna/DNA_node_types.h @@ -374,6 +374,10 @@ enum { CMP_NODE_DILATEERODE_DISTANCE_FEATHER = 3 }; +enum { + CMP_NODE_INPAINT_SIMPLE = 0 +}; + enum { CMP_NODEFLAG_MASK_AA = (1 << 0), CMP_NODEFLAG_MASK_NO_FEATHER = (1 << 1), diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c index 472b0693ae5..eadd4f16a8a 100644 --- a/source/blender/makesrna/intern/rna_nodetree.c +++ b/source/blender/makesrna/intern/rna_nodetree.c @@ -2103,6 +2103,26 @@ static void def_cmp_dilate_erode(StructRNA *srna) RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); } +static void def_cmp_inpaint(StructRNA *srna) +{ + PropertyRNA *prop; + +/* + prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + + RNA_def_property_enum_sdna(prop, NULL, "custom1"); + RNA_def_property_enum_items(prop, type_items); + RNA_def_property_ui_text(prop, "Type", "Type of inpaint algorithm"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); +*/ + + prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE); + RNA_def_property_int_sdna(prop, NULL, "custom2"); + RNA_def_property_range(prop, 1, 10000); + RNA_def_property_ui_text(prop, "Distance", "Distance to inpaint (number of iterations)"); + RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update"); +} + static void def_cmp_scale(StructRNA *srna) { PropertyRNA *prop; diff --git a/source/blender/makesrna/intern/rna_nodetree_types.h b/source/blender/makesrna/intern/rna_nodetree_types.h index a4837a88b17..c70dd01cd57 100644 --- a/source/blender/makesrna/intern/rna_nodetree_types.h +++ b/source/blender/makesrna/intern/rna_nodetree_types.h @@ -121,6 +121,7 @@ DefNode( CompositorNode, CMP_NODE_TRANSLATE, 0, "TRANS DefNode( CompositorNode, CMP_NODE_ZCOMBINE, def_cmp_zcombine, "ZCOMBINE", Zcombine, "Z Combine", "" ) DefNode( CompositorNode, CMP_NODE_COMBRGBA, 0, "COMBRGBA", CombRGBA, "Combine RGBA", "" ) DefNode( CompositorNode, CMP_NODE_DILATEERODE, def_cmp_dilate_erode, "DILATEERODE", DilateErode, "Dilate/Erode", "" ) +DefNode( CompositorNode, CMP_NODE_INPAINT, def_cmp_inpaint, "INPAINT", Inpaint, "Inpaint", "" ) DefNode( CompositorNode, CMP_NODE_ROTATE, def_cmp_rotate, "ROTATE", Rotate, "Rotate", "" ) DefNode( CompositorNode, CMP_NODE_SCALE, def_cmp_scale, "SCALE", Scale, "Scale", "" ) DefNode( CompositorNode, CMP_NODE_SEPYCCA, def_cmp_ycc, "SEPYCCA", SepYCCA, "Separate YCCA", "" ) diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt index e8dd4acb63b..d95751af82f 100644 --- a/source/blender/nodes/CMakeLists.txt +++ b/source/blender/nodes/CMakeLists.txt @@ -74,6 +74,7 @@ set(SRC composite/nodes/node_composite_huecorrect.c composite/nodes/node_composite_idMask.c composite/nodes/node_composite_image.c + composite/nodes/node_composite_inpaint.c composite/nodes/node_composite_invert.c composite/nodes/node_composite_keyingscreen.c composite/nodes/node_composite_keying.c diff --git a/source/blender/nodes/NOD_composite.h b/source/blender/nodes/NOD_composite.h index 3b4fa49ea05..92e547288c9 100644 --- a/source/blender/nodes/NOD_composite.h +++ b/source/blender/nodes/NOD_composite.h @@ -80,6 +80,7 @@ void register_node_type_cmp_dblur(struct bNodeTreeType *ttype); void register_node_type_cmp_bilateralblur(struct bNodeTreeType *ttype); void register_node_type_cmp_vecblur(struct bNodeTreeType *ttype); void register_node_type_cmp_dilateerode(struct bNodeTreeType *ttype); +void register_node_type_cmp_inpaint(struct bNodeTreeType *ttype); void register_node_type_cmp_defocus(struct bNodeTreeType *ttype); void register_node_type_cmp_valtorgb(struct bNodeTreeType *ttype); diff --git a/source/blender/nodes/composite/nodes/node_composite_inpaint.c b/source/blender/nodes/composite/nodes/node_composite_inpaint.c new file mode 100644 index 00000000000..dc4177bd2a4 --- /dev/null +++ b/source/blender/nodes/composite/nodes/node_composite_inpaint.c @@ -0,0 +1,61 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * 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. + * + * The Original Code is Copyright (C) 2006 Blender Foundation. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/nodes/composite/nodes/node_composite_inpaint.c + * \ingroup cmpnodes + */ + + +#include "node_composite_util.h" + + +/* **************** Inpaint/ ******************** */ + +static bNodeSocketTemplate cmp_node_inpaint_in[] = { + {SOCK_RGBA, 1, N_("Image"), 1.0f, 1.0f, 1.0f, 1.0f}, + { -1, 0, "" } +}; +static bNodeSocketTemplate cmp_node_inpaint_out[] = { + {SOCK_RGBA, 0, N_("Image")}, + { -1, 0, "" } +}; + +static void node_composit_exec_inpaint(void *UNUSED(data), bNode *UNUSED(node), bNodeStack **UNUSED(in), bNodeStack **UNUSED(out)) +{ +} + +void register_node_type_cmp_inpaint(bNodeTreeType *ttype) +{ + static bNodeType ntype; + + node_type_base(ttype, &ntype, CMP_NODE_INPAINT, "Inpaint", NODE_CLASS_OP_FILTER, NODE_OPTIONS); + node_type_socket_templates(&ntype, cmp_node_inpaint_in, cmp_node_inpaint_out); + node_type_size(&ntype, 130, 100, 320); + node_type_exec(&ntype, node_composit_exec_inpaint); + + nodeRegisterType(ttype, &ntype); +} -- cgit v1.2.3