image inpaintingreadmeWord文档下载推荐.docx

1、 the picture window and the concole window. The primary user activity is drawing the mask over the area to be repaired. The mask is drawn with the left mouse button and erased with the right mouse button. Whenever the user initiates a file I/O operation, the file name is to be typed into the console

2、 window.left mouse drag - draw maskright mouse drag - erase maskC - clear masku - unlimited undo （of mask drawing）r - redo （mask drawing）U - toggle undo on/off （off saves some memory - not much）b - brush size （rotate between three sizes）t - toggle mask display on/offc - cycle through mask colorss -

3、save imageM - save maskL - load mask+ - one iteration of inpaintingd - one iteration of anisotropic diffusionD - toggle diffusion on/offi - 100 iterations, followed by a step of diffusion, if diffusion is onI - 2000 iterations, followed by a step of diffusion, if diffusion is onV - specify how many

4、blocks of 100 iterations of inpainting to do, followed by a step ofdiffusion, if diffusion is ona - 15 iterations of inpainting, followed by 2 steps of diffusionA - specify how many blocks of 15i/2dINPAINTING:The inpainting algorithm measures the smoothness of the image and uses this to decide how t

5、o extend contours through the masked region. It uses the Laplacian as a smoothness indicator. Tofind edge contours, we us a vector perpendicular to the gradient. The gradient of the image points in the direction of greatest increase. Along edges, the gradient points perpendicular to the edge because

6、 the greatest change in the value of the image is across an edge. Image inpainting is an iterative algorithm that only changes pixels in the mask. In order to get from step n to step n+1:define L（x,y） = 2D Laplacian at pixel （x,y）dL is a vector, the change in smoothness to the left, right, top, and

7、bottom of the current pixelN is a vector, a vector perpendicular to the gradientG is a scalar, a measure of the length of the gradientUpdate is a pixel arrayImage is a pixel array, the image at step nImageNext is a pixel array, the image at step n+1deltat is a scalar, the step size for updating an i

8、magefor every pixel （x,y） in the mask dL（x,y） = （L（x+1,y） - L（x-1,y）, L（x,y+1） - L（x,j-1） N = normalized vector perpendicular to gradient B = dL . N G = length*（N） Update（x,y） = B * G ImageNext（x,y） = Image（x,y） + deltat * Update（x,y）length* is a special measure of length that needs to be used in or

9、der to get stable results. It isdefined as_x - x direction_y - y direction_f - forward derivative - calculate derivative as difference between pixel in front and currentpixel_b - backard derivative - calculate derivative as difference between current pixel and pixel inback_m - minimum of value and 0

10、_M - maximum of value and 0if （B 0） length* = sqrt（Image_xbm2 + Image_xfM2 + Image_ybm2 + Image_yfM2）else length* = sqrt（Image_xbM2 + Image_xfm2 + Image_ybM2 + Image_yfm2）ANISOTROPIC DIFFUSION:After every several steps of inpainting, we run an iteration of anisotropic diffusion. Anisotropicdiffusion

11、 is one approach to noise removal because it tends to sharpen edges while smoothing overcontinuous regions. It is used here for two reasons. It helps to smooth over some of the partsfilled in by the inpainting algorithm. It also helps to join edges across the mask as they arebeing drawn in so that t

12、hey will be continuous. We adapted Robert EstessMCD algorithm for our use.OPTIMIZATIONSWe implemented a number of optimizations in an effort to make the program faster and more responsive. The image is kept in a format that GL can read directly （which allows for fairly quick redraws）. However, for l

13、arge images, even this incurs a noticable delay, so for most mask and image manipulations, we draw the changed pixels directly to the screen to avoid whole-image redraws. The mask itself is stored in a bitfield, and we developed fast algorithms for iteration and modification which utilize the fact t

14、hat the mask is usually sparse. Undo and redo are also memory-efficient; although we must dynamically allocate memory as the user interacts with the program, we use a dynamic, scalable vector class which avoids costly linked lists and pointers. As a result each pixel change requires only about 10 by

15、tes of storage on average （4 each for x and y coords, 1 for indicating the type of operation, and 1 on average for pointing to the next vector）.For the inpainting and diffusion algorithms, we used inline functions and pass-by-reference as much as possible, and tried to avoid tedious iterations over

16、the whole image. Diffusion is a very costly algorithm; our current implementation requires about 3x as much memory to run as the original image. There are likely more efficient implementations out there, but we couldnt think of a better way to implement it that would still be fast.-Published Paperps fileOriginal Paper: Preprinthttp:/www.ima.umn.edu/preprints/dec99/dec99.htmlAnisotropic Diffusion Code/info.cipic.ucdavis.edu/ftp/estes/ Implementation of inpainting/www-users.itlabs.umn.edu/rams0053/