def collapse(lapl_pyr): '''Reconstruct the image based on its laplacian pyramid. lapl_pyr - a laplacian pyramid, as constructed by the lapl_pyramid function, or returned by the blend function. output - an image of the same shape as the base layer of the pyramid and dtype float. Note: sometimes expand will return an image that is larger than the next layer. In this case, you should crop the expanded image down to the size of the next layer. For example, expanding a layer of size 3x4 will result in an image of size 6x8. If the next layer is of size 5x7, crop the expanded image to size 5x7. ''' output = None # Insert your code here ------------------------------------------------------ while len(lapl_pyr) > 1: first = part0.expand(lapl_pyr[-1]) second = lapl_pyr[-2] rows_expanded, cols_expanded = first.shape rows, cols = second.shape if rows_expanded > rows: first = first[:-1,:] if cols_expanded > cols: first = first[:,:-1] lapl_pyr = lapl_pyr[:-2] lapl_pyr.append(first + second) output = lapl_pyr[0] # ---------------------------------------------------------------------------- return output
def collapse(lapl_pyr): '''Reconstruct the image based on its laplacian pyramid. lapl_pyr - a laplacian pyramid, as constructed by the lapl_pyramid function, or returned by the blend function. output - an image of the same shape as the base layer of the pyramid and dtype float. Note: sometimes expand will return an image that is larger than the next layer. In this case, you should crop the expanded image down to the size of the next layer. For example, expanding a layer of size 3x4 will result in an image of size 6x8. If the next layer is of size 5x7, crop the expanded image to size 5x7. ''' output = None # Insert your code here ------------------------------------------------------ for i in range(len(lapl_pyr)-1, 0, -1): # expand layer k and add to layer k-1 (expand_to_r, expand_to_c) = (lapl_pyr[i-1].shape[0], lapl_pyr[i-1].shape[1]) lapl_pyr[i-1] = part0.expand(lapl_pyr[i])[0:expand_to_r, 0:expand_to_c] + lapl_pyr[i-1] # only base layer should be returned output = lapl_pyr[0] # ---------------------------------------------------------------------------- return output
def collapse(lapl_pyr): '''Reconstruct the image based on its laplacian pyramid. lapl_pyr - a laplacian pyramid, as constructed by the lapl_pyramid function, or returned by the blend function. output - an image of the same shape as the base layer of the pyramid and dtype float. Note: sometimes expand will return an image that is larger than the next layer. In this case, you should crop the expanded image down to the size of the next layer. For example, expanding a layer of size 3x4 will result in an image of size 6x8. If the next layer is of size 5x7, crop the expanded image to size 5x7. ''' output = np.zeros(lapl_pyr[0].shape, dtype = 'float') print lapl_pyr , output l = len(lapl_pyr) output = lapl_pyr[l-1] for i in range(l-1, 0, -1): expand_image = part0.expand(output) if (lapl_pyr[i-1].shape[0] != expand_image.shape[0] ): expand_image = expand_image[0:lapl_pyr[i-1].shape[0],:] if (lapl_pyr[i-1].shape[1] != expand_image.shape[1] ): expand_image = expand_image[:, 0:lapl_pyr[i-1].shape[1]] output = expand_image + lapl_pyr[i-1] return output
def lapl_pyramid(gauss_pyr): '''Construct a laplacian pyramid from the gaussian pyramid, of height levels. gauss_pyr - a gaussian pyramid as returned by your gauss_pyramid function. output - a laplacian pyramid of the same height as gauss_pyr. This pyramid should be represented in the same way as guass_pyr - as a list of arrays. Every element of the list now corresponds to a layer of the laplacian pyramid, containing the difference between two layers of the gaussian pyramid. output[k] = gauss_pyr[k] - expand(gauss_pyr[k+1]) The last element of output should be identical to the last layer of the input pyramid. Note: sometimes the size of the expanded image will be larger than the given layer. You should crop the expanded image to match in shape with the given layer. For example, if my layer is of size 5x7, reducing and expanding will result in an image of size 6x8. In this case, crop the expanded layer to 5x7. ''' output = [] # Insert your code here ------------------------------------------------------ for k in range(len(gauss_pyr)-1): layer = gauss_pyr[k] - part0.expand(gauss_pyr[k+1])[0:gauss_pyr[k].shape[0], 0:gauss_pyr[k].shape[1]] output.append(layer) output.append(gauss_pyr[-1]) # ---------------------------------------------------------------------------- return output
def collapse(lapl_pyr): '''Reconstruct the image based on its laplacian pyramid. lapl_pyr - a laplacian pyramid, as constructed by the lapl_pyramid function, or returned by the blend function. output - an image of the same shape as the base layer of the pyramid and dtype float. Note: sometimes expand will return an image that is larger than the next layer. In this case, you should crop the expanded image down to the size of the next layer. For example, expanding a layer of size 3x4 will result in an image of size 6x8. If the next layer is of size 5x7, crop the expanded image to size 5x7. ''' output = np.zeros(lapl_pyr[0].shape, dtype='float') print lapl_pyr, output l = len(lapl_pyr) output = lapl_pyr[l - 1] for i in range(l - 1, 0, -1): expand_image = part0.expand(output) if (lapl_pyr[i - 1].shape[0] != expand_image.shape[0]): expand_image = expand_image[0:lapl_pyr[i - 1].shape[0], :] if (lapl_pyr[i - 1].shape[1] != expand_image.shape[1]): expand_image = expand_image[:, 0:lapl_pyr[i - 1].shape[1]] output = expand_image + lapl_pyr[i - 1] return output
def lapl_pyramid(gauss_pyr): '''Construct a laplacian pyramid from the gaussian pyramid, of height levels. gauss_pyr - a gaussian pyramid as returned by your gauss_pyramid function. output - a laplacian pyramid of the same height as gauss_pyr. This pyramid should be represented in the same way as guass_pyr - as a list of arrays. Every element of the list now corresponds to a layer of the laplacian pyramid, containing the difference between two layers of the gaussian pyramid. output[k] = gauss_pyr[k] - expand(gauss_pyr[k+1]) The last element of output should be identical to the last layer of the input pyramid. Note: sometimes the size of the expanded image will be larger than the given layer. You should crop the expanded image to match in shape with the given layer. For example, if my layer is of size 5x7, reducing and expanding will result in an image of size 6x8. In this case, crop the expanded layer to 5x7. ''' output = [[] for i in range(len(gauss_pyr))] for i in range(0, len(gauss_pyr)-1): gauss_image = gauss_pyr[i] expand_image = part0.expand(gauss_pyr[i+1]) if (gauss_image.shape[0] != expand_image.shape[0] ): expand_image = expand_image[0:gauss_image.shape[0],:] if (gauss_image.shape[1] != expand_image.shape[1] ): expand_image = expand_image[:, 0:gauss_image.shape[1]] output[i] = gauss_image - expand_image output[len(gauss_pyr)-1] = gauss_pyr[len(gauss_pyr)-1] # Insert your code here ------------------------------------------------------ # ---------------------------------------------------------------------------- return output
def lapl_pyramid(gauss_pyr): '''Construct a laplacian pyramid from the gaussian pyramid, of height levels. gauss_pyr - a gaussian pyramid as returned by your gauss_pyramid function. output - a laplacian pyramid of the same height as gauss_pyr. This pyramid should be represented in the same way as gauss_pyr - as a list of arrays. Every element of the list now corresponds to a layer of the laplacian pyramid, containing the difference between two layers of the gaussian pyramid. output[k] = gauss_pyr[k] - expand(gauss_pyr[k+1]) The last element of output should be identical to the last layer of the input pyramid. Note: sometimes the size of the expanded image will be larger than the given layer. You should crop the expanded image to match in shape with the given layer. For example, if my layer is of size 5x7, reducing and expanding will result in an image of size 6x8. In this case, crop the expanded layer to 5x7. ''' output = [] # Insert your code here ------------------------------------------------------ for l in xrange(len(gauss_pyr) - 1): expanded_level = part0.expand(gauss_pyr[l + 1]) rows, cols = gauss_pyr[l].shape rows_expanded, cols_expanded = expanded_level.shape if rows_expanded > rows: expanded_level = expanded_level[:-1, :] if cols_expanded > cols: expanded_level = expanded_level[:, :-1] output.append(gauss_pyr[l] - expanded_level) output.append(gauss_pyr[-1]) # ---------------------------------------------------------------------------- return output
def lapl_pyramid(gauss_pyr): '''Construct a laplacian pyramid from the gaussian pyramid, of height levels. gauss_pyr - a gaussian pyramid as returned by your gauss_pyramid function. output - a laplacian pyramid of the same height as gauss_pyr. This pyramid should be represented in the same way as guass_pyr - as a list of arrays. Every element of the list now corresponds to a layer of the laplacian pyramid, containing the difference between two layers of the gaussian pyramid. output[k] = gauss_pyr[k] - expand(gauss_pyr[k+1]) The last element of output should be identical to the last layer of the input pyramid. Note: sometimes the size of the expanded image will be larger than the given layer. You should crop the expanded image to match in shape with the given layer. For example, if my layer is of size 5x7, reducing and expanding will result in an image of size 6x8. In this case, crop the expanded layer to 5x7. ''' output = [] # Insert your code here ------------------------------------------------------ print "STARTING MY CODE" output = [(np.zeros((5,), dtype=np.float)) for i in range(len(gauss_pyr))] #part0.expand(gauss_pyr[i+1])[:-1,:] print "SIZE:" print len(output) for i in range(len(output)): if(i+1<len(output)): print i+1 print "Shape" print gauss_pyr[i].shape print gauss_pyr[i].shape[0] print gauss_pyr[i].shape[1] a = part0.expand(gauss_pyr[i+1])#[:-1,:] b = gauss_pyr[i] print a print b #print np.append(a,b,axis=0) print a.shape print b.shape if b.shape <> a.shape: print "Doing Work" x, y = b.shape a = a[:x,:y] print a #c = np.vstack[a,b] #print c output[i]=b-a else:#(i==len(gauss_pyr)-1): print "My Pramid" print gauss_pyr[i] output[i]=gauss_pyr[i] #else: #output[i]=part0.expand(gauss_pyr[i+1])[:-1,:] print "END" print output print "END MY CODE" # ---------------------------------------------------------------------------- return output
def lapl_expand(image, desired_shape): attempt = part0.expand(image) if attempt.shape == desired_shape: return attempt return attempt[0:desired_shape[0], 0:desired_shape[1]]