def __init__(self, I, J, height, width):

self.i = I

self.j = J

self.h = height

self.w = width

def getHeight(self):

return self.h

def getWidth(self):

return self.w

def isMissing(self, pixelI,pixelJ):

return self.i <= pixelI < self.i+self.h \

and self.j <= pixelJ < self.j+self.w

def isMissingPatch(self, patch):

return self.isMissing(patch.i, patch.j) \

# We search in a rectangle whose size is proportional

# to the size of the missing region

search_rect_w = math.ceil(0.5*SEARCH_SPACE_FACTOR*unknown_region.getWidth())

search_rect_h = math.ceil(0.5*SEARCH_SPACE_FACTOR*unknown_region.getHeight())

# The threshold to have a minimum offset between the closest patches

threshold = 2*max(search_rect_w,search_rect_h)*THRESHOLD_FACTOR

# The search rectangle has to stay inside the image

startI = max(0, patch_i - search_rect_h)

stopI = min(all_patches.shape[0], patch_i + search_rect_h)

startJ = max(0, patch_j - search_rect_w)

stopJ = min(all_patches.shape[1], patch_j + search_rect_w)

dists = np.inf * np.ones((stopI - startI, stopJ - startJ))

patch_compared = all_patches[patch_i, patch_j]

# Loop to compute the distance from our patch to all the othes

# This is where the inefficiency comes from

for i in range(startI, stopI):

for j in range(startJ, stopJ):

norm = (startI + i - patch_i)**2 + (startJ + j - patch_j)**2

# Tests if the two patches aren't too close

if (norm > threshold): ### WARNING, WE DON'T TEST YET FOR THE MISSING REGION

current_patch = all_patches[startI + i, startJ + j]

dists[i,j] = patch_dist(patch_compared, current_patch)

min_flattened = dists.argmin()

n_columns = stopJ - startJ

# Computation of the minimum position coordinates

min_pos_i = min_flattened // n_columns

min_pos_j = min_flattened % n_columns

best_offset_i = startI + min_pos_i - patch_i

best_offset_j = startJ + min_pos_j - patch_j

(im_height, im_width) = im.shape

all_patches = image.extract_patches_2d(im, (patch_size, patch_size))

nb_rows = im_height - patch_size + 1

nb_cols = im_width - patch_size + 1

# The array of patches is reshaped to have each patch indexed by its

# coordinates in the image

all_patches = all_patches.reshape( nb_rows, nb_cols, patch_size, patch_size)

#The size of the histogram is determined by the maximum offsets possible

hist_height = 2*min(im_height, SEARCH_SPACE_FACTOR*missing_region.getHeight())

hist_width = 2*min(im_width, SEARCH_SPACE_FACTOR*missing_region.getWidth())

hist = np.zeros((hist_height, hist_width))

for i in range(nb_rows):

for j in range(nb_cols):

(x, y) = closest_patch(i, j, all_patches, missing_region)

# The zero of the offsets is the center of the histogram

hist[hist_height//2 + x, hist_width//2 + y] += 1