inpaint node from tomato branch by Peter Schlaile
authorCampbell Barton <ideasman42@gmail.com>
Mon, 6 Aug 2012 13:45:11 +0000 (13:45 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 6 Aug 2012 13:45:11 +0000 (13:45 +0000)
http://en.wikipedia.org/wiki/Inpainting

15 files changed:
source/blender/blenkernel/BKE_node.h
source/blender/blenkernel/intern/node.c
source/blender/compositor/CMakeLists.txt
source/blender/compositor/intern/COM_Converter.cpp
source/blender/compositor/nodes/COM_InpaintNode.cpp [new file with mode: 0644]
source/blender/compositor/nodes/COM_InpaintNode.h [new file with mode: 0644]
source/blender/compositor/operations/COM_InpaintOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_InpaintOperation.h [new file with mode: 0644]
source/blender/editors/space_node/drawnode.c
source/blender/makesdna/DNA_node_types.h
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_nodetree_types.h
source/blender/nodes/CMakeLists.txt
source/blender/nodes/NOD_composite.h
source/blender/nodes/composite/nodes/node_composite_inpaint.c [new file with mode: 0644]

index 0d867bbbb519f9a5f57540540450ec3929307712..61845619452840871d1c874a57f6abe985699b3f 100644 (file)
@@ -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
index c600ab5ebea0adefd3bbad26b6fb1912573f4dec..8670f86cd678d8f477bb53c2a1b8d0cb32d072ad 100644 (file)
@@ -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);
index 870e379b3436781e8e0a4bcfcc78af8c78a19ab7..4dc111cebd2692b05227b87990afe6d3906c5f85 100644 (file)
@@ -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
index 37d38261ea56bb469c7fdbd240445e28a9d7d73a..24c3c36b79e347cbe2a8cced0b867733041967f8 100644 (file)
@@ -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 (file)
index 0000000..e90a392
--- /dev/null
@@ -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 (file)
index 0000000..5837b97
--- /dev/null
@@ -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 (file)
index 0000000..5b21273
--- /dev/null
@@ -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 (file)
index 0000000..0ff6517
--- /dev/null
@@ -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
index de882bd3635ea4203a6b97099c466ee7af85b81d..3e34c369a6922a51194916d4b7a4233543aad9a4 100644 (file)
@@ -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;
index 731f44d256401d0a3e640af5cb168f6fe080a1b8..d0c2a5c9925307ec3ccdb46c9411a59d5de6ab25 100644 (file)
@@ -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),
index 472b0693ae5e22ba9a9fb9f0de498b211f6fdb1e..eadd4f16a8a3f552246a40f928ee4e713a8ba7b7 100644 (file)
@@ -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;
index a4837a88b1722a4562b306061f7c0dcf54e912a4..c70dd01cd57b1a20f22e1d06f4d8d488a72fbb45 100644 (file)
@@ -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",     ""              )
index e8dd4acb63b46499d6423cfff85fcefe569b5aa3..d95751af82f6ee493809f549c9071ecd2190b6a1 100644 (file)
@@ -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
index 3b4fa49ea05f0f12c126894d74a0c828b4958963..92e547288c90c427b6799f4a0c22745f29816160 100644 (file)
@@ -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 (file)
index 0000000..dc4177b
--- /dev/null
@@ -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);
+}