cimg.cxx 3.6.3

package/plugins/inpaint.h

@@ -0,0 +1,508 @@
+/*
+ #
+ #  File        : inpaint.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Copyright   : David Tschumperlé
+ #
+ #  Description  :
+ #
+ #  This plug-in implements the patch-based inpainting algorithm for 2d images, as
+ #  described in the two following publications :
+ #
+ #  "A Smarter Examplar-based Inpainting Algorithm using Local and Global Heuristics
+ #   for more Geometric Coherence."
+ #  (M. Daisy, P. Buyssens, D. Tschumperlé, O. Lezoray).
+ #  IEEE International Conference on Image Processing (ICIP'14), Paris/France, Oct. 2014
+ #
+ #  and
+ #
+ #  "A Fast Spatial Patch Blending Algorithm for Artefact Reduction in Pattern-based
+ #   Image Inpainting."
+ #  (M. Daisy, D. Tschumperlé, O. Lezoray).
+ #  SIGGRAPH Asia 2013 Technical Briefs, Hong-Kong, November 2013.
+ #
+ #  Licenses    : This file is 'dual-licensed', you have to choose one
+ #                of the two licenses below to apply.
+ #
+ #                CeCILL-C
+ #                The CeCILL-C license is close to the GNU LGPL.
+ #                ( http://cecill.info/licences/Licence_CeCILL-C_V1-en.html )
+ #
+ #                or  CeCILL v2.1
+ #                The CeCILL license is compatible with the GNU GPL.
+ #                ( http://cecill.info/licences/Licence_CeCILL_V2.1-en.html )
+ #
+ #  This software is governed either by the CeCILL or the CeCILL-C license
+ #  under French law and abiding by the rules of distribution of free software.
+ #  You can  use, modify and or redistribute the software under the terms of
+ #  the CeCILL or CeCILL-C licenses as circulated by CEA, CNRS and INRIA
+ #  at the following URL: "http://cecill.info".
+ #
+ #  As a counterpart to the access to the source code and  rights to copy,
+ #  modify and redistribute granted by the license, users are provided only
+ #  with a limited warranty  and the software's author,  the holder of the
+ #  economic rights,  and the successive licensors  have only  limited
+ #  liability.
+ #
+ #  In this respect, the user's attention is drawn to the risks associated
+ #  with loading,  using,  modifying and/or developing or reproducing the
+ #  software by the user in light of its specific status of free software,
+ #  that may mean  that it is complicated to manipulate,  and  that  also
+ #  therefore means  that it is reserved for developers  and  experienced
+ #  professionals having in-depth computer knowledge. Users are therefore
+ #  encouraged to load and test the software's suitability as regards their
+ #  requirements in conditions enabling the security of their systems and/or
+ #  data to be ensured and,  more generally, to use and operate it in the
+ #  same conditions as regards security.
+ #
+ #  The fact that you are presently reading this means that you have had
+ #  knowledge of the CeCILL and CeCILL-C licenses and that you accept its terms.
+ #
+*/
+#ifndef cimg_plugin_inpaint
+#define cimg_plugin_inpaint
+
+template<typename t>
+CImg<T>& inpaint_patch(const CImg<t>& mask, const unsigned int patch_size=11,
+                       const unsigned int lookup_size=22, const float lookup_factor=1,
+                       const int lookup_increment=1,
+                       const unsigned int blend_size=0, const float blend_threshold=0.5f,
+                       const float blend_decay=0.02, const unsigned int blend_scales=10,
+                       const bool is_blend_outer=false) {
+  if (depth()>1)
+    throw CImgInstanceException(_cimg_instance
+                                "inpaint_patch(): Instance image is volumetric (should be 2d).",
+                                cimg_instance);
+  if (!is_sameXYZ(mask))
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Sizes of instance image and specified mask "
+                                "(%u,%u,%u,%u) do not match.",
+                                cimg_instance,
+                                mask._width,mask._height,mask._depth,mask._spectrum);
+  if (!patch_size)
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Specified patch size is 0, must be strictly "
+                                "positive.",
+                                cimg_instance);
+  if (!lookup_size)
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Specified lookup size is 0, must be strictly "
+                                "positive.",
+                                cimg_instance);
+  if (lookup_factor<0)
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Specified lookup factor %g is negative, must be "
+                                "positive.",
+                                cimg_instance,
+                                lookup_factor);
+  if (!lookup_increment)
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Specified lookup increment is 0, must be "
+                                "strictly positive.",
+                                cimg_instance);
+  if (blend_decay<0)
+    throw CImgArgumentException(_cimg_instance
+                                "inpaint_patch() : Specified blend decay %g is negative, must be "
+                                "positive.",
+                                cimg_instance,
+                                blend_decay);
+
+  // Find (dilated by 2) bounding box for the inpainting mask.
+  unsigned int xm0 = _width, ym0 = _height, xm1 = 0, ym1 = 0;
+  bool is_mask_found = false;
+  cimg_forXY(mask,x,y) if (mask(x,y)) {
+    is_mask_found = true;
+    if (x<(int)xm0) xm0 = (unsigned int)x;
+    if (x>(int)xm1) xm1 = (unsigned int)x;
+    if (y<(int)ym0) ym0 = (unsigned int)y;
+    if (y>(int)ym1) ym1 = (unsigned int)y;
+  }
+  if (!is_mask_found) return *this;
+  xm0 = xm0>2?xm0 - 2:0;
+  ym0 = ym0>2?ym0 - 2:0;
+  xm1 = xm1<_width - 3?xm1 + 2:_width - 1;
+  ym1 = ym1<_height - 3?ym1 + 2:_height - 1;
+  int ox = xm0, oy = ym0;
+  unsigned int dx = xm1 - xm0 + 1U, dy = ym1 - ym0 + 1U;
+
+  // Construct normalized version of the mask.
+  CImg<ucharT> nmask(dx,dy);
+  unsigned char *ptrM = nmask.data();
+  cimg_for_inXY(mask,xm0,ym0,xm1,ym1,x,y) *(ptrM++) = mask(x,y)?0:1;
+  xm0 = ym0 = 0; xm1 = dx - 1; ym1 = dy - 1;
+
+  // Start patch filling algorithm.
+  const int p2 = (int)patch_size/2, p1 = (int)patch_size - p2 - 1;
+  const unsigned int patch_size2 = patch_size*patch_size;
+  unsigned int _lookup_size = lookup_size, nb_lookups = 0, nb_fails = 0, nb_saved_patches = 0;
+  bool is_strict_search = true;
+  const float one = 1;
+
+  CImg<floatT> confidences(nmask), priorities(dx,dy,1,2,-1), pC;
+  CImg<unsigned int> saved_patches(4,256), is_visited(width(),height(),1,1,0);
+  CImg<ucharT> pM, pN;  // Pre-declare patch variables (avoid iterative memory alloc/dealloc)
+  CImg<T> pP, pbest;
+  CImg<floatT> weights(patch_size,patch_size,1,1,0);
+  weights.draw_gaussian((float)p1,(float)p1,patch_size/15.0f,&one)/=patch_size2;
+  unsigned int target_index = 0;
+
+  while (true) {
+
+    // Extract mask border points and compute priorities to find target point.
+    unsigned int nb_border_points = 0;
+    float target_confidence = -1, target_priority = -1;
+    int target_x = -1, target_y = -1;
+    CImg_5x5(M,unsigned char);
+
+    cimg_for_in5x5(nmask,xm0,ym0,xm1,ym1,x,y,0,0,M,unsigned char)
+      if (!Mcc && (Mcp || Mcn || Mpc || Mnc)) { // Found mask border point
+
+        float confidence_term = -1, data_term = -1;
+        if (priorities(x,y)>=0) { // If priority has already been computed
+          confidence_term = priorities(x,y,0);
+          data_term = priorities(x,y,1);
+        } else { // If priority must be computed/updated
+
+          // Compute smoothed normal vector.
+          const float
+            // N = smoothed 3x3 neighborhood of M.
+            Npc = (4.0f*Mpc + 2.0f*Mbc + 2.0f*Mcc + 2.0f*Mpp + 2.0f*Mpn + Mbp + Mbn + Mcp + Mcn)/16,
+            Nnc = (4.0f*Mnc + 2.0f*Mac + 2.0f*Mcc + 2.0f*Mnp + 2.0f*Mnn + Map + Man + Mcp + Mcn)/16,
+            Ncp = (4.0f*Mcp + 2.0f*Mcb + 2.0f*Mcc + 2.0f*Mpp + 2.0f*Mnp + Mpb + Mnb + Mpc + Mnc)/16,
+            Ncn = (4.0f*Mcn + 2.0f*Mca + 2.0f*Mcc + 2.0f*Mpn + 2.0f*Mnn + Mpa + Mna + Mpc + Mnc)/16,
+            _nx = 0.5f*(Nnc - Npc),
+            _ny = 0.5f*(Ncn - Ncp),
+            nn = std::sqrt(1e-8f + _nx*_nx + _ny*_ny),
+            nx = _nx/nn,
+            ny = _ny/nn;
+
+          // Compute confidence term.
+          nmask._inpaint_patch_crop(x - p1,y - p1,x + p2,y + p2,1).move_to(pM);
+          confidences._inpaint_patch_crop(x - p1,y - p1,x + p2,y + p2,1).move_to(pC);
+          confidence_term = 0;
+          const unsigned char *ptrM = pM.data();
+          cimg_for(pC,ptrC,float) confidence_term+=*ptrC**(ptrM++);
+          confidence_term/=patch_size2;
+          priorities(x,y,0) = confidence_term;
+
+          // Compute data term.
+          _inpaint_patch_crop(ox + x - p1,oy + y - p1,ox + x + p2,oy + y + p2,2).move_to(pP);
+          float mean_ix2 = 0, mean_ixiy = 0, mean_iy2 = 0;
+
+          CImg_3x3(I,T);
+          CImg_3x3(_M, unsigned char);
+          cimg_forC(pP,c) cimg_for3x3(pP,p,q,0,c,I,T) {
+            // Compute weight-mean of structure tensor inside patch.
+            cimg_get3x3(pM,p,q,0,0,_M,unsigned char);
+            const float
+              ixf = (float)(_Mnc*_Mcc*(Inc - Icc)),
+              iyf = (float)(_Mcn*_Mcc*(Icn - Icc)),
+              ixb = (float)(_Mcc*_Mpc*(Icc - Ipc)),
+              iyb = (float)(_Mcc*_Mcp*(Icc - Icp)),
+              ix = cimg::abs(ixf)>cimg::abs(ixb)?ixf:ixb,
+              iy = cimg::abs(iyf)>cimg::abs(iyb)?iyf:iyb,
+              w = weights(p,q);
+            mean_ix2 += w*ix*ix;
+            mean_ixiy += w*ix*iy;
+            mean_iy2 += w*iy*iy;
+          }
+          const float // Compute tensor-directed data term
+            ux = mean_ix2*(-ny) + mean_ixiy*nx,
+            uy = mean_ixiy*(-ny) + mean_iy2*nx;
+          data_term = std::sqrt(ux*ux + uy*uy);
+          priorities(x,y,1) = data_term;
+        }
+        const float priority = confidence_term*data_term;
+        if (priority>target_priority) {
+          target_priority = priority; target_confidence = confidence_term;
+          target_x = ox + x; target_y = oy + y;
+        }
+        ++nb_border_points;
+      }
+    if (!nb_border_points) break; // No more mask border points to inpaint!
+
+    // Locate already reconstructed neighbors (if any), to get good origins for patch lookup.
+    CImg<unsigned int> lookup_candidates(2,256);
+    unsigned int nb_lookup_candidates = 0, *ptr_lookup_candidates = lookup_candidates.data();
+    const unsigned int *ptr_saved_patches = saved_patches.data();
+    const int
+      x0 = target_x - (int)patch_size, y0 = target_y - (int)patch_size,
+      x1 = target_x + (int)patch_size, y1 = target_y + (int)patch_size;
+    for (unsigned int k = 0; k<nb_saved_patches; ++k) {
+      const unsigned int
+        src_x = *(ptr_saved_patches++), src_y = *(ptr_saved_patches++),
+        dest_x = *(ptr_saved_patches++), dest_y = *(ptr_saved_patches++);
+      if ((int)dest_x>=x0 && (int)dest_y>=y0 && (int)dest_x<=x1 && (int)dest_y<=y1) {
+        const int off_x = target_x - dest_x, off_y = target_y - dest_y;
+        *(ptr_lookup_candidates++) = src_x + off_x;
+        *(ptr_lookup_candidates++) = src_y + off_y;
+        if (++nb_lookup_candidates>=lookup_candidates._height)
+          lookup_candidates.resize(2,-200,1,1,0);
+      }
+    }
+    // Add also target point as a center for the patch lookup.
+    *(ptr_lookup_candidates++) = target_x;
+    *(ptr_lookup_candidates++) = target_y;
+    ++nb_lookup_candidates;
+
+    // Divide size of lookup regions if several lookup sources have been detected.
+    unsigned int final_lookup_size = _lookup_size;
+    if (nb_lookup_candidates>1) {
+      const unsigned int
+        _final_lookup_size = (unsigned int)cimg::round(_lookup_size*lookup_factor/
+                                                       std::sqrt((float)nb_lookup_candidates),1,1);
+      final_lookup_size = _final_lookup_size + 1 - (_final_lookup_size%2);
+    }
+    const int l2 = (int)final_lookup_size/2, l1 = (int)final_lookup_size - l2 - 1;
+
+#ifdef inpaint_debug
+    CImg<ucharT> visu(*this,false);
+    for (unsigned int C = 0; C<nb_lookup_candidates; ++C) {
+      const int
+        xl = lookup_candidates(0,C),
+        yl = lookup_candidates(1,C);
+      visu.draw_rectangle(xl - l1,yl - l1,xl + l2,yl + l2,CImg<ucharT>::vector(0,255,0).data(),0.2f);
+    }
+    visu.draw_rectangle(target_x - p1,target_y - p1,target_x + p2,target_y + p2,
+                        CImg<ucharT>::vector(255,0,0).data(),0.5f);
+    static int foo = 0;
+    if (!(foo%1)) {
+      //      visu.save("video.ppm",foo);
+      static CImgDisplay disp_debug;
+      disp_debug.display(visu).set_title("DEBUG");
+    }
+    ++foo;
+#endif // #ifdef inpaint_debug
+
+    // Find best patch candidate to fill target point.
+    _inpaint_patch_crop(target_x - p1,target_y - p1,target_x + p2,target_y + p2,0).move_to(pP);
+    nmask._inpaint_patch_crop(target_x - ox - p1,target_y - oy - p1,target_x - ox + p2,target_y - oy  + p2,0).
+      move_to(pM);
+    ++target_index;
+    const unsigned int
+      _lookup_increment = (unsigned int)(lookup_increment>0?lookup_increment:
+                                         nb_lookup_candidates>1?1:-lookup_increment);
+    float best_ssd = cimg::type<float>::max();
+    int best_x = -1, best_y = -1;
+    for (unsigned int C = 0; C<nb_lookup_candidates; ++C) {
+      const int
+        xl = (int)lookup_candidates(0,C),
+        yl = (int)lookup_candidates(1,C),
+        x0 = std::max(p1,xl - l1), y0 = std::max(p1,yl - l1),
+        x1 = std::min(width() - 1 - p2,xl + l2), y1 = std::min(height() - 1 - p2,yl + l2);
+      for (int y = y0; y<=y1; y+=_lookup_increment)
+        for (int x = x0; x<=x1; x+=_lookup_increment) if (is_visited(x,y)!=target_index) {
+            if (is_strict_search) mask._inpaint_patch_crop(x - p1,y - p1,x + p2,y + p2,1).move_to(pN);
+            else nmask._inpaint_patch_crop(x - ox - p1,y - oy - p1,x - ox + p2,y - oy + p2,0).move_to(pN);
+            if ((is_strict_search && pN.sum()==0) || (!is_strict_search && pN.sum()==patch_size2)) {
+              _inpaint_patch_crop(x - p1,y - p1,x + p2,y + p2,0).move_to(pC);
+              float ssd = 0;
+              const T *_pP = pP._data;
+              const float *_pC = pC._data;
+              cimg_for(pM,_pM,unsigned char) { if (*_pM) {
+                  cimg_forC(pC,c) {
+                    ssd+=cimg::sqr((Tfloat)*_pC - (Tfloat)*_pP); _pC+=patch_size2; _pP+=patch_size2;
+                  }
+                  if (ssd>=best_ssd) break;
+                  _pC-=pC._spectrum*patch_size2;
+                  _pP-=pC._spectrum*patch_size2;
+                }
+                ++_pC; ++_pP;
+              }
+              if (ssd<best_ssd) { best_ssd = ssd; best_x = x; best_y = y; }
+            }
+            is_visited(x,y) = target_index;
+          }
+    }
+
+    if (best_x<0) { // If no best patch found
+      priorities(target_x - ox,target_y - oy,0)/=10; // Reduce its priority (lower data_term)
+      if (++nb_fails>=4) { // If too much consecutive fails :
+        nb_fails = 0;
+        _lookup_size+=_lookup_size/2; // Try to expand the lookup size
+        if (++nb_lookups>=3) {
+          if (is_strict_search) { // If still fails, switch to non-strict search mode
+            is_strict_search = false;
+            _lookup_size = lookup_size;
+            nb_lookups = 0;
+          }
+          else return *this; // Pathological case, probably a weird mask
+        }
+      }
+    } else { // Best patch found -> reconstruct missing part on the target patch
+      _lookup_size = lookup_size;
+      nb_lookups = nb_fails = 0;
+      _inpaint_patch_crop(best_x - p1,best_y - p1,best_x + p2,best_y + p2,0).move_to(pbest);
+      nmask._inpaint_patch_crop(target_x - ox - p1,target_y - oy - p1,target_x - ox + p2,target_y - oy + p2,1).
+        move_to(pM);
+      cimg_for(pM,ptr,unsigned char) *ptr=1 - *ptr;
+      draw_image(target_x - p1,target_y - p1,pbest,pM,1,1);
+      confidences.draw_image(target_x - ox - p1,target_y - oy - p1,pC.fill(target_confidence),pM,1,1);
+      nmask.draw_rectangle(target_x - ox - p1,target_y - oy - p1,0,0,target_x - ox + p2,target_y - oy + p2,0,0,1);
+      priorities.draw_rectangle(target_x - ox - (int)patch_size,
+                                target_y - oy - (int)patch_size,0,0,
+                                target_x - ox + 3*p2/2,
+                                target_y - oy + 3*p2/2,0,0,-1);
+      // Remember patch positions.
+      unsigned int *ptr_saved_patches = saved_patches.data(0,nb_saved_patches);
+      *(ptr_saved_patches++) = best_x;
+      *(ptr_saved_patches++) = best_y;
+      *(ptr_saved_patches++) = target_x;
+      *ptr_saved_patches = target_y;
+      if (++nb_saved_patches>=saved_patches._height) saved_patches.resize(4,-200,1,1,0);
+    }
+  }
+  nmask.assign();  // Free some unused memory resources
+  priorities.assign();
+  confidences.assign();
+  is_visited.assign();
+
+  // Blend inpainting result (if requested), using multi-scale blending algorithm.
+  if (blend_size && blend_scales) {
+    const float _blend_threshold = std::max(0.0f,std::min(1.0f,blend_threshold));
+    saved_patches._height = nb_saved_patches;
+
+    // Re-crop image and mask if outer blending is activated.
+    if (is_blend_outer) {
+      const int
+        b2 = (int)blend_size/2, b1 = (int)blend_size - b2 - 1,
+        xb0 = std::max(0,ox - b1),
+        yb0 = std::max(0,oy - b1),
+        xb1 = std::min(_width - 1,xb0 + dx + b1 + b2),
+        yb1 = std::min(_height - 1,yb0 + dy + b1 + b2);
+      ox = xb0; oy = yb0; dx = xb1 - xb0 + 1U, dy = yb1 - yb0 + 1U;
+    }
+
+    // Generate map of source offsets.
+    CImg<unsigned int> offsets(dx,dy,1,2);
+    unsigned int *ptr = saved_patches.end();
+    cimg_forY(saved_patches,i) {
+      const unsigned int yd = *(--ptr), xd = *(--ptr), ys = *(--ptr), xs = *(--ptr);
+      for (int l = -p1; l<=p2; ++l)
+        for (int k = -p1; k<=p2; ++k) {
+          const int xdk = xd + k, ydl = yd + l;
+          if (xdk>=0 && xdk<=width() - 1 && ydl>=0 && ydl<=height() - 1 && mask(xd + k,yd + l)) {
+            offsets(xd - ox + k,yd - oy + l,0) = xs + k;
+            offsets(xd - ox + k,yd - oy + l,1) = ys + l;
+          }
+        }
+    }
+    unsigned int *ptrx = offsets.data(0,0,0,0), *ptry = offsets.data(0,0,0,1);
+    cimg_forXY(offsets,x,y) {
+      if (!mask(x + ox,y + oy)) { *ptrx = x + ox; *ptry = y + oy; }
+      ++ptrx; ++ptry;
+    }
+
+    // Generate map of local blending amplitudes.
+    CImg<floatT> blend_map(dx,dy,1,1,0);
+    CImg_3x3(I,float);
+    cimg_for3XY(offsets,x,y) if (mask(x + ox,y + oy)) {
+      const float
+        iox = std::max((float)offsets(_n1x,y,0) - offsets(x,y,0),
+                       (float)offsets(x,y,0) - offsets(_p1x,y,0)),
+        ioy = std::max((float)offsets(x,_n1y,1) - offsets(x,y,1),
+                       (float)offsets(x,y,1) - offsets(x,_p1y,1)),
+        ion = std::sqrt(iox*iox + ioy*ioy);
+      float iin = 0;
+      cimg_forC(*this,c) {
+        cimg_get3x3(*this,x,y,0,c,I,float);
+        const float
+          iix = (float)std::max(Inc - Icc,Icc - Ipc),
+          iiy = (float)std::max(Icn - Icc,Icc - Icp);
+        iin+=std::log(1 + iix*iix + iiy*iiy);
+      }
+      iin/=_spectrum;
+      blend_map(x,y) = ion*iin;
+    }
+    blend_map.threshold(blend_map.max()*_blend_threshold).distance(1);
+    cimg_forXY(blend_map,x,y) blend_map(x,y) = 1/(1 + blend_decay*blend_map(x,y));
+    blend_map.quantize(blend_scales + 1,false);
+    float bm, bM = blend_map.max_min(bm);
+    if (bm==bM) blend_map.fill((float)blend_scales);
+
+    // Generate blending scales.
+    CImg<T> result = _inpaint_patch_crop(ox,oy,ox + dx - 1,oy + dy - 1,0);
+    for (unsigned int blend_iter = 1; blend_iter<=blend_scales; ++blend_iter) {
+      const unsigned int
+        _blend_width = blend_iter*blend_size/blend_scales,
+        blend_width = _blend_width?_blend_width + 1 - (_blend_width%2):0;
+      if (!blend_width) continue;
+      const int b2 = (int)blend_width/2, b1 = (int)blend_width - b2 - 1;
+      CImg<floatT>
+        blended = _inpaint_patch_crop(ox,oy,ox + dx - 1,oy + dy - 1,0),
+        cumul(dx,dy,1,1);
+      weights.assign(blend_width,blend_width,1,1,0).
+        draw_gaussian((float)b1,(float)b1,blend_width/4.0f,&one);
+      cimg_forXY(cumul,x,y) cumul(x,y) = mask(x + ox,y + oy)?0.0f:1.0f;
+      blended.mul(cumul);
+
+      cimg_forY(saved_patches,l) {
+        const unsigned int *ptr = saved_patches.data(0,l);
+        const int
+          xs = (int)*(ptr++),
+          ys = (int)*(ptr++),
+          xd = (int)*(ptr++),
+          yd = (int)*(ptr++);
+        if (xs - b1<0 || ys - b1<0 || xs + b2>=width() || ys + b2>=height()) { // Blend with partial patch
+          const int
+            xs0 = std::max(0,xs - b1),
+            ys0 = std::max(0,ys - b1),
+            xs1 = std::min(width() - 1,xs + b2),
+            ys1 = std::min(height() - 1,ys + b2);
+          _inpaint_patch_crop(xs0,ys0,xs1,ys1,0).move_to(pP);
+          weights._inpaint_patch_crop(xs0 - xs + b1,ys0 - ys + b1,xs1 - xs + b1,ys1 - ys + b1,0).move_to(pC);
+          blended.draw_image(xd + xs0 - xs - ox,yd + ys0 - ys - oy,pP,pC,-1);
+          cumul.draw_image(xd + xs0 - xs - ox,yd + ys0 - ys - oy,pC,-1);
+        } else { // Blend with full-size patch
+          _inpaint_patch_crop(xs - b1,ys - b1,xs + b2,ys + b2,0).move_to(pP);
+          blended.draw_image(xd - b1 - ox,yd - b1 - oy,pP,weights,-1);
+          cumul.draw_image(xd - b1 - ox,yd - b1 - oy,weights,-1);
+        }
+      }
+
+      if (is_blend_outer) {
+        cimg_forXY(blended,x,y) if (blend_map(x,y)==blend_iter) {
+          const float cum = cumul(x,y);
+          if (cum>0) cimg_forC(*this,c) result(x,y,c) = (T)(blended(x,y,c)/cum);
+        }
+      } else { cimg_forXY(blended,x,y) if (mask(x + ox,y + oy) && blend_map(x,y)==blend_iter) {
+          const float cum = cumul(x,y);
+          if (cum>0) cimg_forC(*this,c) result(x,y,c) = (T)(blended(x,y,c)/cum);
+        }
+      }
+    }
+    if (is_blend_outer) draw_image(ox,oy,result);
+    else cimg_forXY(result,x,y) if (mask(x + ox,y + oy))
+           cimg_forC(*this,c) (*this)(x + ox,y + oy,c) = (T)result(x,y,c);
+  }
+  return *this;
+}
+
+// Special crop function that supports more boundary conditions :
+// 0=dirichlet (with value 0), 1=dirichlet (with value 1) and 2=neumann.
+CImg<T> _inpaint_patch_crop(const int x0, const int y0, const int x1, const int y1,
+                            const unsigned int boundary=0) const {
+  const int
+    nx0 = x0<x1?x0:x1, nx1 = x0^x1^nx0,
+    ny0 = y0<y1?y0:y1, ny1 = y0^y1^ny0;
+  CImg<T> res(1U + nx1 - nx0,1U + ny1 - ny0,1,_spectrum);
+  if (nx0<0 || nx1>=width() || ny0<0 || ny1>=height()) {
+    if (boundary>=2) cimg_forXYZC(res,x,y,z,c) res(x,y,z,c) = _atXY(nx0 + x,ny0 + y,z,c);
+    else res.fill((T)boundary).draw_image(-nx0,-ny0,*this);
+  } else res.draw_image(-nx0,-ny0,*this);
+  return res;
+}
+
+template<typename t>
+CImg<T> get_inpaint_patch(const CImg<t>& mask, const unsigned int patch_size=11,
+                          const unsigned int lookup_size=22, const float lookup_factor=1,
+                          const int lookup_increment=1,
+                          const unsigned int blend_size=0, const float blend_threshold=0.5,
+                          const float blend_decay=0.02f, const unsigned int blend_scales=10,
+                          const bool is_blend_outer=false) const {
+  return (+*this).inpaint_patch(mask,patch_size,lookup_size,lookup_factor,lookup_increment,
+                                blend_size,blend_threshold,blend_decay,blend_scales,is_blend_outer);
+}
+
+#endif /* cimg_plugin_inpaint */