def upsample_interp23(image, ratio): image = np.transpose(image, (2, 0, 1)) b, r, c = image.shape CDF23 = 2 * np.array([ 0.5, 0.305334091185, 0, -0.072698593239, 0, 0.021809577942, 0, -0.005192756653, 0, 0.000807762146, 0, -0.000060081482 ]) d = CDF23[::-1] CDF23 = np.insert(CDF23, 0, d[:-1]) BaseCoeff = CDF23 first = 1 for z in range(1, np.int(np.log2(ratio)) + 1): I1LRU = np.zeros((b, 2**z * r, 2**z * c)) if first: I1LRU[:, 1:I1LRU.shape[1]:2, 1:I1LRU.shape[2]:2] = image first = 0 else: I1LRU[:, 0:I1LRU.shape[1]:2, 0:I1LRU.shape[2]:2] = image for ii in range(0, b): t = I1LRU[ii, :, :] for j in range(0, t.shape[0]): t[j, :] = ndimage.correlate(t[j, :], BaseCoeff, mode='wrap') for k in range(0, t.shape[1]): t[:, k] = ndimage.correlate(t[:, k], BaseCoeff, mode='wrap') I1LRU[ii, :, :] = t image = I1LRU re_image = np.transpose(I1LRU, (1, 2, 0)) return re_image
def step(self): """ Perform single automaton step. """ gsum = sum(self.grid) # Compute burn touched cells maximum(1, self.grid, self.burn_map) self.burn_map -= 1 # Correlate cells for next set of fires correlate(self.burn_map, self.spread, mode='constant', cval=0, output=self.next_burn_map) # And cutoff at 1 and multiply by grid to remove # barren cells. self.next_burn_map *= self.grid minimum(1, self.next_burn_map, self.next_burn_map) # Finally ignite next set of trees and top at barren self.grid += self.next_burn_map self.grid += self.burn_map minimum(3, self.grid, self.grid) if p.sleep: __import__('time').sleep(p.sleep) # No more fire? return gsum < sum(self.grid)
def _compute_patch_size_of_cover_types(self, lct, footprint): """Computes the mean size of all patches of covertypes of interest that are (partially) within each cell's footprint""" eightway_structure = ones( (3, 3), dtype="int32") # put this to class variable will result in error patchsizes = zeros(shape=lct.shape, dtype=float32) patchcount = zeros(shape=lct.shape, dtype=float32) labels, n = label(lct, eightway_structure) slices = find_objects(labels) # Summing the 0/1 mask gives the patch size for ip in range(n): locmask = where(labels[slices[ip]] == (ip + 1), lct[slices[ip]], 0) patchcount[slices[ip]] += locmask patchsizes[slices[ip]] += locmask.sum() * locmask del locmask pcount_corr = correlate(patchcount, footprint, mode="reflect", cval=0.0) psize_corr = correlate(patchsizes, footprint, mode="reflect", cval=0.0) nonzeros = where(pcount_corr <> 0) result = zeros(psize_corr.shape, dtype=float32) result[nonzeros] = psize_corr[nonzeros] / pcount_corr[nonzeros] return result
def sobel(img): ''' edges = sobel(img) Compute edges using Sobel's algorithm `edges` is a binary image of edges computed according to Matlab's implementation of Sobel's algorithm. Parameters ---------- img : Any 2D-ndarray Returns ------- edges : Binary image of edges ''' # This is based on Octave's implementation, # but with some reverse engineering to match Matlab exactly img = img.astype(np.float) img = (img-img.min())/img.ptp() vfiltered = ndimage.correlate(img, _vsobel_filter, mode='nearest') # This emulates Matlab's implementation hfiltered = ndimage.correlate(img, _hsobel_filter, mode='nearest') filtered = vfiltered**2 + hfiltered**2 thresh = 2*np.sqrt(filtered.mean()) filtered *= (np.sqrt(filtered) < thresh) r,c = filtered.shape x = (filtered > np.hstack((np.zeros((r,1)),filtered[:,:-1]))) & (filtered > np.hstack((filtered[:,1:], np.zeros((r,1))))) y = (filtered > np.vstack((np.zeros(c),filtered[:-1,:]))) & (filtered > np.vstack((filtered[1:,:], np.zeros(c)))) return x | y
def harris_corner_detector(image, window_size, stddev, thresh): image_gray = rgb2gray(image) # CREATE GAUSSIAN WINDOW FILTER if window_size%2==0: window_size=window_size+1 k = int((window_size-1)/2) window = np.zeros((window_size, window_size)) window[k, k] = 1 window = ndimage.gaussian_filter(window, sigma=stddev) # FIND IMAGE GRADIENT TERMS G, I_x, I_y = gradient(image_gray) I_xx = I_x * I_x I_yy = I_y * I_y I_xy = I_x * I_y # COMPUTE M M_11 = ndimage.correlate(I_xx, window, mode='nearest') M_12 = M_21 = ndimage.correlate(I_xy, window, mode='nearest') M_22 = ndimage.correlate(I_yy, window, mode='nearest') # COMPUTE CORNERNESS R alpha = 0.04 R = (M_11 * M_22 - M_12 * M_21) - alpha * (M_11 + M_22)**2 # THRESHOLD R threshold = thresh R[R<threshold] = 0 # NON-LOCAL-MAXIMUM SUPRESSION Corners = find_local_maximum(R) return R, Corners
def convolveLayer(inputTensor, kernel, stride, padding=0): kernelSizeY, kernelSizeX = np.shape(kernel) strideX, strideY = getBinaryParameter(stride) paddingX, paddingY = getBinaryParameter(padding) #convert inputTensor's dim to 3 inputShapeLen = len(inputTensor.shape) if inputShapeLen == 1: inputTensor = np.expand_dims(inputTensor, 0) inputTensor = np.expand_dims(inputTensor, 0) pass elif inputShapeLen == 2: inputTensor = np.expand_dims(inputTensor, 0) elif inputShapeLen == 3: pass else: #error pass # concatnate input array with padding inputTensor = concatnateInputWithPadding(inputTensor, paddingX, paddingY) resultTensor = None correlate(inputTensor, kernel, resultTensor, mode="constant") return resultTensor
def createFilterBank(): # Code to generate reasonable filter bank gaussianScales = [1, 2, 4, 8, math.sqrt(2) * 8] logScales = [1, 2, 4, 8, math.sqrt(2) * 8] dxScales = [1, 2, 4, 8, math.sqrt(2) * 8] dyScales = [1, 2, 4, 8, math.sqrt(2) * 8] filterBank = [] for scale in gaussianScales: siz = 2 * math.ceil(scale * 2.5) + 1 tmp = gaussian(shape=(siz, siz), sigma=scale) filterBank.append(tmp) for scale in logScales: siz = 2 * math.ceil(scale * 2.5) + 1 tmp = laplacian_of_gaussian(shape=(siz, siz), sigma=scale) filterBank.append(tmp) xgrad = np.array([[-1, 0, 1]]) for scale in dxScales: siz = 2 * math.ceil(scale * 2.5) + 1 f = gaussian(shape=(siz, siz), sigma=scale) f = ndimage.correlate(f, xgrad) filterBank.append(f) for scale in dyScales: f = gaussian(shape=(siz, siz), sigma=scale) f = ndimage.correlate(f, xgrad.transpose()) filterBank.append(f) return filterBank
def interp23(image, ratio): if (2**round(np.log2(ratio)) != ratio): # print 'Error: only resize factors of power 2' return b, r, c = image.shape CDF23 = 2 * np.array([ 0.5, 0.305334091185, 0, -0.072698593239, 0, 0.021809577942, 0, -0.005192756653, 0, 0.000807762146, 0, -0.000060081482 ]) d = CDF23[::-1] CDF23 = np.insert(CDF23, 0, d[:-1]) BaseCoeff = CDF23 first = 1 for z in range(1, np.int(np.log2(ratio)) + 1): I1LRU = np.zeros((b, 2**z * r, 2**z * c)) if first: I1LRU[:, 1:I1LRU.shape[1]:2, 1:I1LRU.shape[2]:2] = image first = 0 else: I1LRU[:, 0:I1LRU.shape[1]:2, 0:I1LRU.shape[2]:2] = image for ii in range(0, b): t = I1LRU[ii, :, :] for j in range(0, t.shape[0]): t[j, :] = ndimage.correlate(t[j, :], BaseCoeff, mode='wrap') for k in range(0, t.shape[1]): t[:, k] = ndimage.correlate(t[:, k], BaseCoeff, mode='wrap') I1LRU[ii, :, :] = t image = I1LRU return image
def _activate(self, inputs, out, cval=np.nan): """Generate input activities for neurons (convolve and add bias).""" out[...] = 0. ndimage.correlate(inputs, self.filter, mode='constant', cval=cval, output=out) if self.biases.size > 0: out[self.active_slice] += self.biases
def rankBoxes(frame, boxSize, k=1, energyBlur=32, captionId=None, objBox=None, prevPositions={}): grayFrame = rgb2gray(frame) grayFrame = ndimage.gaussian_filter(grayFrame, 1.5, mode='nearest') height, width = boxSize halfHeight, halfWidth = math.ceil(height / 2), math.ceil(width / 2) frameHeight, frameWidth, _ = frame.shape # differentiation filter filterX = [[1, 0, -1], [1, 0, -1], [1, 0, -1]] filterY = [[1, 1, 1], [0, 0, 0], [-1, -1, -1]] gx = ndimage.correlate(grayFrame, filterX, mode='nearest') gy = ndimage.correlate(grayFrame, filterY, mode='nearest') energy = np.abs(gx) + np.abs(gy) if captionId is not None and captionId in prevPositions: energy[prevPositions[captionId]] -= energyBlur**2 * 512 if objBox is not None: objX, objY, objWidth, objHeight = objBox midX, midY = objX + objWidth // 2, objY + objHeight // 2 midX, midY = max(0, min(frameWidth - 1, midX)), max(0, min(frameHeight - 1, midY)) energy[objY, midX] -= 512 * energyBlur**2 energy = ndimage.gaussian_filter(energy, energyBlur, mode='constant', cval=0) boxFilter = np.ones(boxSize) filtered = ndimage.correlate(energy, boxFilter, mode='constant', cval=0) if objBox is not None: objX, objY, objWidth, objHeight = objBox midX, midY = objX + objWidth // 2, objY + objHeight // 2 midX, midY = max(0, min(frameWidth - 1, midX)), max(0, min(frameHeight - 1, midY)) filtered[:, :max(min(midX - objWidth, frameWidth - 1), 0)] += 10000 filtered[:, max(min(midX + objWidth, frameWidth - 1), 0):] += 10000 filtered[:max(min(objY - objHeight, frameHeight - 1), 0), :] += 10000 filtered[max(min(objY + objHeight, frameHeight - 1), 0):, :] += 10000 filtered[:halfHeight, :] = np.inf filtered[frameHeight - halfHeight:, :] = np.inf filtered[:, :halfWidth] = np.inf filtered[:, frameWidth - halfWidth:] = np.inf bestY, bestX = np.unravel_index(np.argmin(filtered), filtered.shape) if captionId is not None: prevPositions[captionId] = (bestY, bestX) return [(bestX - halfWidth, bestY - halfHeight)]
def get_part_scores(E,log_part_blocks,log_invpart_blocks, frequency_mode='valid',time_mode='same'): part_block_shape = log_part_blocks[0].shape if time_mode=='valid': t_start = part_block_shape[0]/2 t_end = t_start + E.shape[0] - part_block_shape[0] + 1 else: # feature_mode == 'same' # TODO: check whether I should make the modes available # type-safe t_start = 0 t_end = E.shape[0] # check the frequency parameters if frequency_mode=='valid': f_start = part_block_shape[1]/2 f_end = f_start + E.shape[1] - part_block_shape[1] + 1 else: # frequency_mode == 'same' f_start = 0 f_end = E.shape[1] e_pos = part_block_shape[2]/2 return np.array([ (ndimage.correlate(E,log_part_block)[t_start:t_end, f_start:f_end, e_pos] +ndimage.correlate(1-E,log_invpart_block)[t_start:t_end, f_start:f_end, e_pos]) for log_part_block,log_invpart_block in zip(log_part_blocks, log_invpart_blocks)])
def makeCorrImg(movie, numNeighbours): # taken from epnev ca_source_extraction if numNeighbours == 8: neighbourhood = np.array(((1, 1, 1), (1, 0, 1), (1, 1, 1))) elif numNeighbours == 4: neighbourhood = np.array(((0, 1, 0), (1, 0, 1), (0, 1, 0))) neighbourhood = neighbourhood.reshape((1, 3, 3)) d0, d1, d2 = movie.shape # centering mY = movie.mean(axis=0) movie = movie - mY # normalizing sY = np.sqrt(np.mean(movie**2, axis=0)) movie = movie * (1 / sY) # compute the correlation Yconv = correlate(movie, neighbourhood) # sum over the neighbouring pixels MASK = correlate(np.ones((1, d1, d2)), neighbourhood) # count the number of neighbouring pixels corrImg = np.mean(Yconv * movie, axis=0) / MASK # compute correlation and normalize corrImg = corrImg.reshape((d1, d2)) return corrImg
def compute(self, dataset_pool): constant = dataset_pool.get_dataset('constants') footprint = constant['FOOTPRINT'] #denominator = dataset.get_attribute(self.footprint_size) - dataset.get_attribute(self.land_cover_type_ow_within_footprint) lct = ma.filled( self.get_dataset().get_2d_attribute(self.land_cover_types), 0) covertypes_of_interest = self._cover_type_translation(constant) is_lct_of_interest = reduce( lambda prev_answer, lct_num: logical_or(prev_answer, lct == lct_num ), covertypes_of_interest, zeros(shape=lct.shape)).astype(int32) lct_mask = logical_not(self.get_dataset().get_mask(is_2d_version=True)) temp = not_equal(lct, constant['OW']) denominator = correlate((temp & lct_mask).astype(int32), footprint, mode='reflect') #denominator = dataset.flatten_by_id(denominator); values = correlate(is_lct_of_interest, footprint, mode="reflect") #pct = dataset.get_attribute(self.land_cover_type_within_footprint).astype(float32) / \ pct = values.astype(float32) / \ ma.masked_where(denominator==0, denominator) pct = ma.filled(pct, 0.0) return self.get_dataset().flatten_by_id(arcsin(sqrt(pct)))
def bf_fluo_correlate(embryo_idx, bf_image, fluo_image, normalized=False, smoothed=None, dim=3): """Plot correlation between bf/fluo images, pixel-by-pixel or smoothed in tiles.""" norm_str = ('N' if normalized else 'Unn') + 'ormalized' smooth_str = 'unsmoothed' if normalized: bf_image = normalize_img(bf_image) fluo_image = normalize_img(fluo_image) if smoothed: if smoothed == 'avg': weights = [[1 / (dim**2)] * dim] * dim bf_image = correlate(bf_image, weights) fluo_image = correlate(fluo_image, weights) elif smoothed == 'max': bf_image = maximum_filter(bf_image, size=dim) fluo_image = maximum_filter(fluo_image, size=dim) elif smoothed == 'min': bf_image = minimum_filter(bf_image, size=dim) fluo_image = minimum_filter(fluo_image, size=dim) else: raise Exception('smoothed can only be avg, max, or min') smooth_str = 'smoothed by ' + smoothed plt.scatter(bf_image.flatten(), fluo_image.flatten()) plt.xlabel(f"{norm_str} bf frame val") plt.ylabel(f"{norm_str} fluo frame val") plt.title(f"Correlation plot for {smooth_str} embryo {embryo_idx}") plt.show()
def warp(self): if self.display: print 'Warp %d' % (self.counter, ) u0, v0 = self.u.copy(), self.v.copy() idxx = self.idx + u0 idyy = self.idy + v0 idxx = np.clip(idxx, 0, self.N - 1) idyy = np.clip(idyy, 0, self.M - 1) I1warped = interp2linear(self.I1, idxx, idyy).astype(theano.config.floatX) if self.display: #plt.figure() #plt.imshow(I1warped) print "I1warped", I1warped print "I0", self.I0 print "u0", u0 print "v0", v0 pass It = I1warped - self.I0 if self.display: print "It", It Ix = ndimage.correlate(I1warped, self.mask, mode='nearest') Iy = ndimage.correlate(I1warped, self.mask.T, mode='nearest') # boundary handling m = (idxx > self.N - 1) | (idxx < 0) | (idyy > self.M - 1) | (idyy < 0) Ix[m] = 0.0 Iy[m] = 0.0 It[m] = 0.0 self.Ix = Ix self.Iy = Iy self.It = It self.train.init(np.zeros_like(self.I0), np.zeros_like(self.I0), Ix, Iy, It) cnt_step = 0 while not self.train.done(): e = self.train.step()[0] if self.display and (cnt_step % 10 == 0 or self.train.done()): print e, cnt_step += 1 if self.display: print # finish line self.u += self.train.tu.get_value() self.v += self.train.tv.get_value() self.counter += 1 if self._intermediate_saver: self._intermediate_saver.save_members(self) self._intermediate_saver.save_locals(locals())
def fusion_images(multispectral, panchromatic, save_image=False, savepath=None, timeCondition=True): end = 0 start = 0 #Verifica que ambas imagenes cumplan con las condiciones if multispectral.shape[2] == 3: print('The Multispectral image has '+str(multispectral.shape[2])+' channels and size of '+str(multispectral.shape[0])+'x'+str(multispectral.shape[1])) else: sys.exit('The first image is not multispectral') if len(panchromatic.shape) == 2: print(' The Panchromatic image has a size of '+str(panchromatic.shape[0])+'x'+str(panchromatic.shape[1])) else: sys.exit('The second image is not panchromatic') start=time.time() hsv = rgb2hsv(multispectral) val = hsv[:,:,2] sat = hsv[:,:,1] mat = hsv[:,:,0] pani = hist_match(panchromatic,val) s = np.array([[1/256, 1/64, 3/128, 1/64, 1/256],[1/64, 1/16, 3/32, 1/16, 1/64],[3/128, 3/32, 9/64, 3/32, 3/128], [1/64, 1/16, 3/32, 1/16, 1/64],[1/256, 1/64, 3/128, 1/64, 1/256]]) I1 = ndimage.correlate(pani, s, mode='constant') s1 = np.array([[1/256, 0, 1/64, 0, 3/128, 0, 1/64, 0, 1/256],[0, 0, 0, 0, 0, 0, 0, 0, 0],[1/64, 0, 1/16, 0, 3/32, 0, 1/16, 0, 1/64],[0, 0, 0, 0, 0, 0, 0, 0, 0], [3/128, 0, 3/32, 0, 9/64, 0, 3/32, 0, 3/128],[0, 0, 0, 0, 0, 0, 0, 0, 0],[1/64, 0, 1/16, 0, 3/32, 0, 1/16, 0, 1/64], [0, 0, 0, 0, 0, 0, 0, 0, 0], [1/256, 0, 1/64, 0, 3/128, 0, 1/64, 0, 1/256]]) I2 = ndimage.correlate(I1, s1, mode='constant') W1=(pani-I1) W1 = adjust_values(W1) W1 = W1.astype(np.uint8) W2=(I1-I2) W2 = adjust_values(W2) W2 = W2.astype(np.uint8) nint=(panchromatic+W1+W2).astype(np.uint8) end = time.time() n_hsv1 = np.stack((mat, sat, nint),axis=2) n_hsv = n_hsv1 fusioned_image = hsv2rgb(n_hsv).astype(np.uint8) if(save_image): # Guarda la imagen resultando de acuerdo al tercer parametro establecido en la linea de ejecución del script if(savepath != None): t = skimage.io.imsave(savepath+'/atrouscpu_image.tif',fusioned_image, plugin='tifffile') else: t = skimage.io.imsave('atrouscpu_image.tif',fusioned_image, plugin='tifffile') #time_calculated de ejecución para la transformada de Brovey en GPU time_calculated = (end-start) if(timeCondition): return {"image": fusioned_image, "time" : time_calculated} else: return fusioned_image
def _compute_pct_cover_type_within_footprint(self, lct, cover_type, footprint, lct_mask): """Calculates percentage of one covertype within the footprint""" temp = equal(lct, cover_type) # use ma.masked_array to prevent divide-by-zero warnings mask_invert = logical_not(lct_mask) # in numpy import ma.masked, 0 == valid pixels = ma.masked_array(correlate(mask_invert.astype(int32), footprint, mode="reflect")) values = correlate(temp.astype(int32), footprint, mode="reflect") return ma.filled(values / pixels.astype(float32), 0)
def warp(self): if self.display: print 'Warp %d' % (self.counter,) u0, v0 = self.u.copy(), self.v.copy() idxx = self.idx + u0 idyy = self.idy + v0 idxx = np.clip(idxx, 0, self.N-1) idyy = np.clip(idyy, 0, self.M-1) I1warped = interp2linear(self.I1, idxx, idyy).astype(theano.config.floatX) if self.display: #plt.figure() #plt.imshow(I1warped) print "I1warped", I1warped print "I0", self.I0 print "u0", u0 print "v0", v0 pass It = I1warped - self.I0 if self.display: print "It", It Ix = ndimage.correlate(I1warped, self.mask, mode='nearest') Iy = ndimage.correlate(I1warped, self.mask.T, mode='nearest') # boundary handling m = (idxx > self.N - 1) | (idxx < 0) | (idyy > self.M - 1) | (idyy < 0) Ix[m] = 0.0 Iy[m] = 0.0 It[m] = 0.0 self.Ix = Ix self.Iy = Iy self.It = It self.train.init(np.zeros_like(self.I0), np.zeros_like(self.I0), Ix, Iy, It) cnt_step = 0 while not self.train.done(): e = self.train.step()[0] if self.display and (cnt_step % 10 == 0 or self.train.done()): print e, cnt_step += 1 if self.display: print # finish line self.u += self.train.tu.get_value() self.v += self.train.tv.get_value() self.counter += 1 if self._intermediate_saver: self._intermediate_saver.save_members(self) self._intermediate_saver.save_locals(locals())
def remove_cell_template(norm, features): if features['_fingers_grid']: # finger grid rh = int(round(features['finger_period_row'])) cw = int(round(features['finger_period_col'])) no_fingers = ndimage.uniform_filter(norm, size=(rh, cw)) features['im_no_fingers'] = no_fingers # remove busbars no_bbs = no_fingers.copy() pixel_ops.InterpolateBBs(no_bbs, np.array(features['_busbar_cols'], np.int32), features['busbar_width'] + 6) features['im_no_figners_bbs'] = no_bbs if False: view = ImageViewer(norm) ImageViewer(no_fingers) ImageViewer(no_bbs) view.show() else: # remove fingers f_len = features['finger_period'] f = np.ones((int(round(f_len)), 1), np.float32) / f_len no_lines = ndimage.correlate(norm, f) # sharpen F_LEN2 = int(round(1.5 * f_len)) f2 = np.ones((1, F_LEN2), np.float32) / F_LEN2 filtered = ndimage.correlate(norm, f2) filtered[filtered < 0.1] = 1.0 if False: view = ImageViewer(norm) ImageViewer(no_lines) ImageViewer(filtered) view.show() edges = norm / filtered no_fingers = edges * no_lines features['im_no_fingers'] = no_fingers if '_busbar_cols' in features: # remove busbars no_bbs = no_fingers.copy() pixel_ops.InterpolateBBs( no_bbs, np.array(features['_busbar_cols'], np.int32), features['busbar_width'] + 6) else: no_bbs = no_fingers features['im_no_figners_bbs'] = no_bbs if False: view = ImageViewer(norm) ImageViewer(no_fingers) ImageViewer(no_bbs) view.show()
def matvec(self, x): # the linear operator is P^T * P * x + mu * D^T * D * x x = x.copy() x.resize(self.spatial_size) return correlate(convolve(x, self.kernel), self.kernel).flatten( ) + self.rho * correlate(convolve( x, self.kernel_h), self.kernel_h).flatten() + self.rho * correlate( convolve(x, self.kernel_v), self.kernel_v).flatten()
def _mean_std(image, w): """Return local mean and standard deviation of each pixel using a neighborhood defined by a rectangular window size ``w``. The algorithm uses integral images to speedup computation. This is used by :func:`threshold_niblack` and :func:`threshold_sauvola`. Parameters ---------- image : ndarray Input image. w : int, or iterable of int Window size specified as a single odd integer (3, 5, 7, …), or an iterable of length ``image.ndim`` containing only odd integers (e.g. ``(1, 5, 5)``). Returns ------- m : ndarray of float, same shape as ``image`` Local mean of the image. s : ndarray of float, same shape as ``image`` Local standard deviation of the image. References ---------- .. [1] F. Shafait, D. Keysers, and T. M. Breuel, "Efficient implementation of local adaptive thresholding techniques using integral images." in Document Recognition and Retrieval XV, (San Jose, USA), Jan. 2008. :DOI:`10.1117/12.767755` """ if not isinstance(w, Iterable): w = (w,) * image.ndim _validate_window_size(w) pad_width = tuple((k // 2 + 1, k // 2) for k in w) padded = np.pad(image.astype('float'), pad_width, mode='reflect') padded_sq = padded * padded integral = integral_image(padded) integral_sq = integral_image(padded_sq) kern = np.zeros(tuple(k + 1 for k in w)) for indices in itertools.product(*([[0, -1]] * image.ndim)): kern[indices] = (-1) ** (image.ndim % 2 != np.sum(indices) % 2) total_window_size = np.prod(w) sum_full = ndi.correlate(integral, kern, mode='constant') m = crop(sum_full, pad_width) / total_window_size sum_sq_full = ndi.correlate(integral_sq, kern, mode='constant') g2 = crop(sum_sq_full, pad_width) / total_window_size # Note: we use np.clip because g2 is not guaranteed to be greater than # m*m when floating point error is considered s = np.sqrt(np.clip(g2 - m * m, 0, None)) return m, s
def weak_texture_mask(img, patchsize, thresh): if img.ndim < 3: img = np.expand_dims(img, 2) kh = np.expand_dims( np.transpose(np.vstack(np.array([-0.5, 0, 0.5]))), 2) imgh = correlate(img, kh, mode="nearest") imgh = imgh[:, 1:imgh.shape[1] - 1, :] imgh = imgh * imgh kv = np.expand_dims(np.vstack(np.array([-0.5, 0, 0.5])), 1) imgv = correlate(img, kv, mode="nearest") imgv = imgv[1:imgv.shape[0] - 1, :, :] imgv = imgv * imgv s = img.shape msk = np.zeros_like(img) for cha in range(s[2]): m = view_as_windows(img[:, :, cha], (patchsize, patchsize)) m = np.zeros_like( m.reshape(np.int(m.size / patchsize**2), patchsize**2, order="F").transpose()) Xh = view_as_windows(imgh[:, :, cha], (patchsize, patchsize - 2)) Xh = Xh.reshape(np.int(Xh.size / ((patchsize - 2) * patchsize)), ((patchsize - 2) * patchsize), order="F").transpose() Xv = view_as_windows(imgv[:, :, cha], (patchsize - 2, patchsize)) Xv = Xv.reshape(np.int(Xv.size / ((patchsize - 2) * patchsize)), ((patchsize - 2) * patchsize), order="F").transpose() Xtr = np.expand_dims( np.sum(np.concatenate((Xh, Xv), axis=0), axis=0), 0) p = Xtr < thresh[cha] ind = 0 for col in range(0, s[1] - patchsize + 1): for row in range(0, s[0] - patchsize + 1): if p[:, ind]: msk[row:row + patchsize - 1, col:col + patchsize - 1, cha] = 1 ind = ind + 1 # clean up img = np.squeeze(img) return np.squeeze(msk)
def _compute_pct_cover_type_within_footprint(self, lct, cover_type, footprint, lct_mask): """Calculates percentage of one covertype within the footprint""" temp = equal(lct, cover_type) # use ma.masked_array to prevent divide-by-zero warnings mask_invert = logical_not( lct_mask) # in numpy import ma.masked, 0 == valid pixels = ma.masked_array( correlate(mask_invert.astype(int32), footprint, mode="reflect")) values = correlate(temp.astype(int32), footprint, mode="reflect") return ma.filled(values / pixels.astype(float32), 0)
def step(G: np.ndarray, herd: complex): '''Perform one timestep for the given herd (east- or south-facing).''' G2 = G.copy() if herd == 1: nei = correlate(G, KERNEL.real, mode='wrap') G2[(G == 0) & (nei.real > 1)] = herd else: nei = correlate(G, KERNEL.imag, mode='wrap') G2[(G == 0) & (nei.imag > 1)] = herd G2[(G == herd) & (nei.imag % 2 == 0) & (nei.real % 2 == 0)] = 0 return G2
def local_normalize(image, ks1, sigma1, ks2, sigma2): #Generate gaussian kernel kernel1 = make_2d_gauss(ks1, sigma1) kernel2 = make_2d_gauss(ks2, sigma2) mu = correlate(image, kernel1) centered = image - mu sd = correlate(centered**2, kernel2)**0.5 return centered / (sd + 1e-9)
def bwmorph_thin(img,n_iter=0): # http://www.mathworks.com/help/images/ref/bwmorph.html#f1-500491 # code adapted from skimage.morphology.skeletonize # FIXME support infinite iteration LUT=[0,0,0,0,0,1,0,1,0,0,0,0,0,1,3,1,0,0,0,0,2,0,2,0,0,0, 0,0,3,1,3,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 2,0,2,0,2,0,0,0,2,0,2,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1, 0,1,2,0,0,0,2,0,2,0,2,0,0,0,2,0,2,0,0,1,0,1,0,1,0,1, 0,0,0,0,0,0,0,0,2,0,0,0,2,0,2,0,2,0,0,0,2,0,2,0,0,0, 0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,3,0,1,0,1,0,1,0,0,0,0,0,1,0,1, 2,2,0,0,2,0,0,0,2,2,0,0,2,0,0,0,3,3,0,1,0,1,0,1,0,0, 0,0,0,0,0,0,2,2,0,0,2,0,0,0,2,2,0,0,2,0,0,0] mask = np.array([[ 1, 2, 4], [128, 0, 8], [ 64, 32, 16]], np.uint8) skeleton = np.array(img).astype(np.uint8) done = False while(not(done)): # assign each pixel a unique value based on its foreground neighbours neighbours = ndimage.correlate(skeleton, mask, mode='constant') # ignore background neighbours *= skeleton # use LUT to extract code for deletion stages of thinning algorithm codes = np.take(LUT, neighbours) done = True # pass 1 - remove the 1's code_mask = (codes == 1) if np.any(code_mask): done = False skeleton[code_mask] = 0 neighbours = ndimage.correlate(skeleton, mask, mode='constant') # ignore background neighbours *= skeleton # use LUT to extract code for deletion stages of thinning algorithm codes = np.take(LUT, neighbours) # pass 2, delete the 2's code_mask = (codes > 1) if np.any(code_mask): done = False skeleton[code_mask] = 0 n_iter -= 1 if n_iter == 0: done = True return skeleton.astype(np.bool)
def _mean_std(image, w): """Return local mean and standard deviation of each pixel using a neighborhood defined by a rectangular window with size w times w. The algorithm uses integral images to speedup computation. This is used by threshold_niblack and threshold_sauvola. Parameters ---------- image : ndarray Input image. w : int Odd window size (e.g. 3, 5, 7, ..., 21, ...). Returns ------- m : 2-D array of same size of image with local mean values. s : 2-D array of same size of image with local standard deviation values. References ---------- .. [1] F. Shafait, D. Keysers, and T. M. Breuel, "Efficient implementation of local adaptive thresholding techniques using integral images." in Document Recognition and Retrieval XV, (San Jose, USA), Jan. 2008. DOI:10.1117/12.767755 """ if w == 1 or w % 2 == 0: raise ValueError("Window size w = %s must be odd and greater than 1." % w) left_pad = w // 2 + 1 right_pad = w // 2 padded = np.pad(image.astype('float'), (left_pad, right_pad), mode='reflect') padded_sq = padded * padded integral = integral_image(padded) integral_sq = integral_image(padded_sq) kern = np.zeros((w + 1, ) * image.ndim) for indices in itertools.product(*([[0, -1]] * image.ndim)): kern[indices] = (-1)**(image.ndim % 2 != np.sum(indices) % 2) sum_full = ndi.correlate(integral, kern, mode='constant') m = crop(sum_full, (left_pad, right_pad)) / (w**image.ndim) sum_sq_full = ndi.correlate(integral_sq, kern, mode='constant') g2 = crop(sum_sq_full, (left_pad, right_pad)) / (w**image.ndim) # Note: we use np.clip because g2 is not guaranteed to be greater than # m*m when floating point error is considered s = np.sqrt(np.clip(g2 - m * m, 0, None)) return m, s
def _mean_std(image, w): """Return local mean and standard deviation of each pixel using a neighborhood defined by a rectangular window with size w times w. The algorithm uses integral images to speedup computation. This is used by threshold_niblack and threshold_sauvola. Parameters ---------- image : ndarray Input image. w : int Odd window size (e.g. 3, 5, 7, ..., 21, ...). Returns ------- m : 2-D array of same size of image with local mean values. s : 2-D array of same size of image with local standard deviation values. References ---------- .. [1] F. Shafait, D. Keysers, and T. M. Breuel, "Efficient implementation of local adaptive thresholding techniques using integral images." in Document Recognition and Retrieval XV, (San Jose, USA), Jan. 2008. DOI:10.1117/12.767755 """ if w == 1 or w % 2 == 0: raise ValueError( "Window size w = %s must be odd and greater than 1." % w) left_pad = w // 2 + 1 right_pad = w // 2 padded = np.pad(image.astype('float'), (left_pad, right_pad), mode='reflect') padded_sq = padded * padded integral = integral_image(padded) integral_sq = integral_image(padded_sq) kern = np.zeros((w + 1,) * image.ndim) for indices in itertools.product(*([[0, -1]] * image.ndim)): kern[indices] = (-1) ** (image.ndim % 2 != np.sum(indices) % 2) sum_full = ndi.correlate(integral, kern, mode='constant') m = crop(sum_full, (left_pad, right_pad)) / (w ** image.ndim) sum_sq_full = ndi.correlate(integral_sq, kern, mode='constant') g2 = crop(sum_sq_full, (left_pad, right_pad)) / (w ** image.ndim) # Note: we use np.clip because g2 is not guaranteed to be greater than # m*m when floating point error is considered s = np.sqrt(np.clip(g2 - m * m, 0, None)) return m, s
def adjoint(self, x, out=None): '''Returns D^{*}(y). The adjoint of convolution is convolution with the PSF rotated by 180 degrees, or equivalently correlation by the PSF itself.''' if out is None: result = self.domain_geometry().allocate() result.fill(correlate(x.as_array(), self.PSF, mode='reflect')) return result else: outarr = out.as_array() correlate(x.as_array(), self.PSF, output=outarr, mode='reflect') out.fill(outarr)
def animate(i): global X, Y, dp, gnd_p, sigma, all_patches, patch, cropax, all_patchax, N if i < N: # If the animation is still running xn = imwarp(dp[i, :] + gnd_p) X[:, i] = xn.reshape(-1) Y[i] = np.exp(-np.dot(dp[i, :], dp[i, :]) / sigma) all_patches[(i * dsize[0]):((i + 1) * dsize[0]), :] = xn cropax.set_data(xn) all_patchax.set_data(all_patches.copy()) all_patchax.autoscale() patch.set_xy(dp[i, :] + gnd_p) return [cropax, patch, all_patchax] else: # Stuff to do after the animation ends # fig3d = plt.figure() # ax3d = fig3d.add_subplot(111, projection='3d') # ax3d.plot_surface(dpx.reshape(dsize), dpy.reshape(dsize), # Y.reshape(dsize), cmap=plt.get_cmap('coolwarm')) # Place your solution code for question 4.3 here # plt.show() data = np.load('X_Y_pairs.npz', X, Y) X = data['arr_0'] Y = data['arr_1'] pdb.set_trace() lamb = 0 g = np.dot(np.linalg.inv(np.dot(X.T, X) + lamb * np.eye(X.shape[0])), np.dot(X.T, Y)) gr0 = g.reshape(dsize) output0 = correlate(img, gr0) lamb = 1 g = np.dot(np.linalg.inv(np.dot(X.T, X) + lamb * np.eye(X.shape[0])), np.dot(X.T, Y)) gr1 = g.reshape(dsize) output1 = correlate(img, gr1) fig, axs = plt.subplots(1, 4, figsize=(6, 2)) axs[0].imshow(gr0) axs[1].imshow(output0, cmap='gray') axs[2].imshow(gr1) axs[3].imshow(output1, cmap='gray') plt.show() output2 = convolve(img, gr0) output3 = convolve(img, gr1) fig, axs = plt.subplots(1, 2, figsize=(4, 2)) axs[0].imshow(output2, cmap='gray') axs[1].imshow(output3, cmap='gray') plt.show() return []
def SpatialCues(im): g = fgaussian([13, 13], np.sqrt(13)) dy = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]] vf = signal.convolve2d(g, dy, boundary='symm', mode='valid') sz = im.shape vC = np.full(sz[1:2], 0) hC = vC for b in range(sz[2]): vC = np.maximum( vC, abs(ndimage.correlate(im[:, :, b], vf, mode='nearest'))) hC = np.maximum( hC, abs(ndimage.correlate(im[:, :, b], vf.transpose(), mode='nearest'))) return hC, vC
def fbcorr(im, f, mode, stride, plugin=None, plugin_kwargs=None): assert mode=='same' if f.ndim == 3 and f.shape[0] == 1: f = f[0, :, :] output = correlate(im, f, mode='constant')[::stride, ::stride] return output elif f.ndim == 4: if f.shape[3] == 1: f = f[:, :, :, 0] output = [correlate(im, fi, mode='nearest') [::stride, ::stride] for fi in f] return np.asarray(output).transpose(1, 2, 0) else: raise NotImplementedError()
def matvec(self, x): x = x.copy() x.resize(self.spatial_size) Dh = convolve(x, self.kernel_h) Dv = convolve(x, self.kernel_v) W_Dh = np.multiply(self.weight, Dh) Dht_W_Dh = correlate(W_Dh, self.kernel_h) W_Dv = np.multiply(self.weight, Dv) Dvt_W_Dv = correlate(W_Dv, self.kernel_v) return (correlate(convolve(x, self.kernel), self.kernel) + self.lmbda * (Dht_W_Dh + Dvt_W_Dv)).flatten()
def run(self, im, skin_thresh=[-1,1], n_peaks=3): ''' im : color image ''' im_skin = rgb2lab(im.astype(np.int16))[:,:,2] self.im_skin = im_skin # im_skin = skimage.exposure.equalize_hist(im_skin) # im_skin = skimage.exposure.rescale_intensity(im_skin, out_range=[0,1]) im_skin *= im_skin > skin_thresh[0] im_skin *= im_skin < skin_thresh[1] skin_match_c = nd.correlate(-im_skin, self.hand_template) self.skin_match = skin_match_c # Display Predictions - Color Based matching optima = peak_local_max(skin_match_c, min_distance=20, num_peaks=n_peaks, exclude_border=False) # Visualize if len(optima) > 0: optima_values = skin_match_c[optima[:,0], optima[:,1]] optima_thresh = np.max(optima_values) / 2 optima = optima.tolist() for i,o in enumerate(optima): if optima_values[i] < optima_thresh: optima.pop(i) break self.markers = optima return self.markers
def scipy_convolution( self ): """Performs the convolution without OpenCL, as a comparison""" im = self.im if self.larger_buffer: if self.dim == 1: im = self.im[self.offset:-self.offset] elif self.dim == 2: im = self.im[self.offset:-self.offset,self.offset:-self.offset] elif self.dim == 3: im = self.im[self.offset:-self.offset,self.offset:-self.offset,self.offset:-self.offset] tstart = time.time() if self.sep: if self.dim == 1: out = ndimage.correlate1d( input=im, weights=self.fil.tolist(), axis=0, mode='wrap', origin=0 ) elif self.dim == 2: out = ndimage.correlate1d( input=im, weights=self.fil.tolist(), axis=0, mode='wrap', origin=0 ) out = ndimage.correlate1d( input=out, weights=self.fil.tolist(), axis=1, mode='wrap', origin=0 ) elif self.dim == 3: out = ndimage.correlate1d( input=im, weights=self.fil.tolist(), axis=0, mode='wrap', origin=0 ) out = ndimage.correlate1d( input=out, weights=self.fil.tolist(), axis=1, mode='wrap', origin=0 ) out = ndimage.correlate1d( input=out, weights=self.fil.tolist(), axis=2, mode='wrap', origin=0 ) else: out = ndimage.correlate( im, self.fil, mode='wrap' ) print "filtered scipy image", time.time() - tstart, "\n", out assert numpy.array_equal( out, self.out ), "The PyOpenCL result does not match with Scipy"
def test_skeletonize_num_neighbours(self): # an empty image image = np.zeros((300, 300)) # foreground object 1 image[10:-10, 10:100] = 1 image[-100:-10, 10:-10] = 1 image[10:-10, -100:-10] = 1 # foreground object 2 rs, cs = draw.bresenham(250, 150, 10, 280) for i in range(10): image[rs + i, cs] = 1 rs, cs = draw.bresenham(10, 150, 250, 280) for i in range(20): image[rs + i, cs] = 1 # foreground object 3 ir, ic = np.indices(image.shape) circle1 = (ic - 135)**2 + (ir - 150)**2 < 30**2 circle2 = (ic - 135)**2 + (ir - 150)**2 < 20**2 image[circle1] = 1 image[circle2] = 0 result = skeletonize(image) # there should never be a 2x2 block of foreground pixels in a skeleton mask = np.array([[1, 1], [1, 1]], np.uint8) blocks = correlate(result, mask, mode='constant') assert not numpy.any(blocks == 4)
def compute(self, dataset_pool): constants = dataset_pool.get_dataset('constants') footprint = constants["FOOTPRINT"] covertypes_of_interest = self._cover_type_translation(constants) lct = ma.filled(self.get_dataset().get_2d_attribute(self.land_cover_type), 0) is_lct_of_interest = reduce(lambda prev_answer, lct_num: logical_or(prev_answer, lct==lct_num), covertypes_of_interest, zeros(shape=lct.shape, dtype=int32)) # maxg: maximum number of possible like-adjacencies within a window # a_i: # of cells of target covertypes within moving window a_i = correlate(ma.filled(is_lct_of_interest.astype(int32), 0), footprint, mode="reflect", cval=0.0) n = floor(sqrt(a_i)) m = a_i - power(n, 2) maxg = 2*n*(n-1) maxg += where(m==0, 0, where(m<=n, (2*m-1), where(m>n, (2*m-2), 0))) # detect all adjacencies by systematically checking each possibility # within the 5x5 footprint window gii = ma.masked_array(zeros(shape=lct.shape, dtype=int32)) for ri in range(0, footprint.shape[0]): for ci in range(0, footprint.shape[1]-1): gii += self._find_adjacency(is_lct_of_interest, (ri,ci), (ri,ci+1), footprint) for ri in range(0, footprint.shape[0]-1): for ci in range(0, footprint.shape[1]): gii += self._find_adjacency(is_lct_of_interest, (ri,ci), (ri+1,ci), footprint) #assert ma.alltrue(ravel(gii<=maxg)) return self.get_dataset().flatten_by_id(arcsin(sqrt(ma.filled(gii/maxg, 0))))
def fonts_template(fn=None,ttf=None): ttf = ttf or 'c:/windows/fonts/ariali.ttf' fn = fn or 'd:/temp/fonts.arrs' m = dict() font = ImageFont.truetype(ttf, 18) for e in '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ': arr = font.getmask(e, mode='L') arr = Image.Image()._new(arr) arr = misc.fromimage(arr) h,w = arr.shape print '%s:<%s,%s> %s'%(e, h,w, arr[0,0]) if w<10: tmp = numpy.ndarray( (h,10), dtype=arr.dtype ) tmp.fill(0) i = (10-w)/2 tmp[:,i:i+w] = arr arr = tmp #arr = arr[3:18,:] arr = arr[2:19,:] arr = im_norm(arr) rs = ndimage.correlate(arr,arr, mode='constant', cval=0.0) limit = numpy.max(rs) m[e] = (limit,arr) cPickle.dump(m, open(fn,'wb'))
def compute(self, dataset_pool): cellsize = dataset_pool.get_dataset('constants')['CELLSIZE'] fpdimension = int(self.footprint_width / cellsize) fp = ones((fpdimension, fpdimension), dtype="int32") summed = correlate( ma.filled( self.get_dataset().get_2d_attribute( self.comm_add ), 0.0 ), \ fp, mode="reflect" ) return ln(self.get_dataset().flatten_by_id(summed)+1)/10.0
def get_part_scores(E,log_part_blocks,log_invpart_blocks): part_block_shape = log_part_blocks[0].shape t_start = part_block_shape[0]/2 t_end = t_start + E.shape[0] - part_block_shape[0] + 1 f_start = part_block_shape[1]/2 f_end = f_start + E.shape[1] - part_block_shape[1] + 1 e_pos = part_block_shape[2]/2 return np.array([ (ndimage.correlate(E,log_part_block)[t_start:t_end, f_start:f_end, e_pos] +ndimage.correlate(1-E,log_invpart_block)[t_start:t_end, f_start:f_end, e_pos]) for log_part_block,log_invpart_block in zip(log_part_blocks, log_invpart_blocks)])
def conway_4d(init: List[str], cycles=6, dim=4) -> int: shape = np.array([len(init), len(init[0])]) shape = np.pad(shape, (dim - shape.size, 0), constant_values=1) space = np.array([list(l) for l in init]) space = (space == "#").astype(int) space = np.reshape(space, shape) space = np.pad(space, cycles) kernel = np.array([0]) kernel = np.reshape(kernel, np.ones(dim, dtype=int)) kernel = np.pad(kernel, 1, constant_values=1) for _ in range(cycles): count = ndimage.correlate(space, kernel, mode="constant", cval=0) c2 = count == 2 c3 = count == 3 c23 = np.logical_or(c2, c3) # 1 -> 1 c11 = np.logical_and(space == 1, c23) # 0 -> 1 c01 = np.logical_and(space == 0, c3) space = np.logical_or(c11, c01).astype(int) return np.count_nonzero(space == 1)
def compute(self, dataset_pool): constants = dataset_pool.get_dataset('constants') footprint = constants["FOOTPRINT"] lct = ma.filled(self.get_dataset().get_2d_attribute(self.land_cover_types), 0) temp = equal(lct, constants[self.lct_type.upper()]) values = correlate(temp.astype(int32), footprint, mode="reflect") return self.get_dataset().flatten_by_id(ma.filled(values, 0))
def test_my_inputs(self): storage = StorageFactory().get_storage('dict_storage') storage.write_table(table_name='land_covers', table_data={ 'relative_x': array([1, 2, 1, 2]), 'relative_y': array([1, 1, 2, 2]), "lct": array([10, 10, 4, 3]) }) dataset_pool = DatasetPool(package_order=['biocomplexity'], storage=storage) footprint = array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]) dataset_pool._add_dataset('constant', { "FOOTPRINT": footprint, 'AG': 10, }) gridcell = dataset_pool.get_dataset('land_cover') gridcell.compute_variables(self.variable_name, dataset_pool=dataset_pool) values = gridcell.get_attribute(self.variable_name) should_be = array([[1, 1], [0, 0]]) should_be = correlate(ma.filled(should_be.astype(int32), 0), footprint, mode="reflect") should_be = less_equal((should_be / 5.0), 400) should_be = ln(distance_transform_edt(should_be) + 1) / dag.standardization_constant_distance should_be = ravel(transpose(should_be)) # flatten by id self.assert_(ma.allclose(values, should_be, rtol=1e-7), msg="Error in " + self.variable_name)
def test_skeletonize_num_neighbours(self): # an empty image image = np.zeros((300, 300)) # foreground object 1 image[10:-10, 10:100] = 1 image[-100:-10, 10:-10] = 1 image[10:-10, -100:-10] = 1 # foreground object 2 rs, cs = draw.line(250, 150, 10, 280) for i in range(10): image[rs + i, cs] = 1 rs, cs = draw.line(10, 150, 250, 280) for i in range(20): image[rs + i, cs] = 1 # foreground object 3 ir, ic = np.indices(image.shape) circle1 = (ic - 135)**2 + (ir - 150)**2 < 30**2 circle2 = (ic - 135)**2 + (ir - 150)**2 < 20**2 image[circle1] = 1 image[circle2] = 0 result = skeletonize(image) # there should never be a 2x2 block of foreground pixels in a skeleton mask = np.array([[1, 1], [1, 1]], np.uint8) blocks = correlate(result, mask, mode='constant') assert not np.any(blocks == 4)
def Ahfunc(self, f): """Conjugate transform - convolve with conj. PSF""" fs = np.reshape(f, (self.height, self.width, self.depth)) d = ndimage.correlate(fs, self.g) return np.ravel(d)
def Ahfunc(self, f): '''Conjugate transform - convolve with conj. PSF''' fs = reshape(f, (self.height, self.width, self.depth)) d = ndimage.correlate(fs, self.g) return ravel(d)
def test_combo(self): """Test subsampling followed by convolution. """ # Forward. var = Variable((2,3)) kernel = np.array([[1,2,3]]) # 2x3 fn = vstack([conv(kernel, subsample(var, (2,1)))]) fn = CompGraph(fn) x = np.arange(6)*1.0 x = np.reshape(x, (2, 3)) out = np.zeros(fn.output_size) fn.forward(x.flatten(), out) y = np.zeros((1,3)) xsub = x[::2,::1] y = ndimage.convolve(xsub, kernel, mode='wrap') self.assertItemsAlmostEqual(np.reshape(out, y.shape), y) # Adjoint. x = np.arange(3)*1.0 x = np.reshape(x, (1, 3)) out = np.zeros(var.size) fn.adjoint(x.flatten(), out) y = ndimage.correlate(x, kernel, mode='wrap') y2 = np.zeros((2,3)) y2[::2,:] = y self.assertItemsAlmostEqual(np.reshape(out, y2.shape), y2) out = np.zeros(var.size) fn.adjoint(x.flatten(), out) self.assertItemsAlmostEqual(np.reshape(out, y2.shape), y2)
def main(): print 'loading data ...' ds = Util.loadData(r'E:\yalongli\Projects\RecoverOrientationData\ds_nx32ny32nz6.dat') qs = Util.loadData(r'E:\yalongli\Projects\RecoverOrientationData\qs_h12s4t3.dat') f = Util.loadData(r'E:\yalongli\Projects\RecoverOrientationData\volumeBin_04.dat') # small test volume f = f[:,:,75:85] print f.shape # Calculate 'J' on these 'q's one by one and store the max_J and max_q in # non-empty cells print 'initialzing J_max, d_max ...' inf = -999999.0 J_max = np.ones_like(f) * inf d_max = np.zeros((f.shape[0], f.shape[1], f.shape[2], 3)) print 'calculating J, d ...' for i in range(qs.shape[0]): J = ndimage.correlate(f, qs[i], mode='constant', cval=1.0) # background = 1.0! update = J > J_max J_max[update] = J[update] d_max[update] = ds[i] if i%100 == 0: print i, '...' # save non-empty cells' result, set empyt cells' direction to zero background = (f > 0.9) d_max[background] = 0.0 print 'saving ...' ori_p = r'E:\yalongli\Projects\RecoverOrientationData\orientationXYZ7585.dat' J_p = r'E:\yalongli\Projects\RecoverOrientationData\JXYZ7585.dat' Util.dumpData(d_max, ori_p) Util.dumpData(J_max, J_p)
def calculate_vector(data1, data2): """ Return translation vector based on correlation. """ if data1.shape != data2.shape: raise ValueError("arrays must have equal shape.") data3 = ndimage.correlate(data1, data2, mode="constant") return [i - int(s / 2) for s, i in zip(data3.shape, np.unravel_index(data3.argmax(), data3.shape))]
def _correlate(self,arr, k, alpha=0.6): limit,V = self.fonts[k] rs = ndimage.correlate(arr,V, mode='constant', cval=0.0) h,w = rs.shape for ij in ( (i,j) for i in xrange(h) for j in xrange(w)): rs[ij] = rs[ij] if rs[ij]>limit*alpha else 0 return ndimage.gaussian_filter(rs, 2)
def _compute_patch_size_of_cover_types(self, lct, footprint): """Computes the mean size of all patches of covertypes of interest that are (partially) within each cell's footprint""" eightway_structure = ones((3,3), dtype="int32") # put this to class variable will result in error patchsizes = zeros(shape=lct.shape, dtype=float32) patchcount = zeros(shape=lct.shape, dtype=float32) labels, n = label(lct, eightway_structure) slices = find_objects(labels) # Summing the 0/1 mask gives the patch size for ip in range(n): locmask = where(labels[slices[ip]]==(ip+1),lct[slices[ip]],0) patchcount[slices[ip]] += locmask patchsizes[slices[ip]] += locmask.sum()*locmask pcount_corr = ma.masked_array(correlate(patchcount, footprint, mode="reflect", cval=0.0)) psize_corr = correlate(patchsizes, footprint, mode="reflect", cval=0.0) return ma.filled(psize_corr / pcount_corr, 0)
def abstract_within_walking_distance_gridcells(attribute, gridcells, filled_value=0, mode="reflect", x_name='relative_x', y_name='relative_y', **kwargs): wd_footprint = set_walking_distance_footprint(**kwargs) attr2d, index2d = get2Dattribute( attribute, gridcells, x_name=x_name, y_name=y_name) summed = ndi.correlate( np.ma.filled(attr2d, filled_value ), wd_footprint, mode=mode) attr2d[:] = summed res = pd.Series(attr2d.stack().reindex(index2d)["value"].values, index=gridcells.index) res[np.isnan(res)] = filled_value return res
def find_perimeter(B): B = np.array(B).astype(np.bool) * 1 """find boundaries via erosion and logical and, using four-connectivity""" #return B & np.invert(binary_erosion(B,FOUR)) S = np.array([[ 0,-1, 0], [-1, 4,-1], [ 0,-1, 0]]) return correlate(B,S) > 0
def _find_adjacency(self, lctmask, p1, p2, footprint): """helper function for aggregation index computation Detects a specific one-way adjacency within each cell's neighborhood, between the two points specified by the tuples p1 and p2.""" adjfp = zeros(shape=footprint.shape, dtype=float32) adjfp[p1] = 0.5 # correlate with weights of 0.5 to count adjfp[p2] = 0.5 # adjacencies in one direction only # do correlation; setting output_type=int32 truncates result, skipping # pairs that are not "real" adjacencies return correlate(lctmask, adjfp, mode="constant", cval=0.0).astype(int32)
def bwmorph_thin(B, n_iter=1): mask = np.array([[ 8, 4, 2], [16, 0, 1], [32, 64,128]],dtype=np.uint8) skel = np.array(B).astype(np.bool).astype(np.uint8) for n in range(n_iter): for lut in [G123_LUT, G123P_LUT]: N = correlate(skel, mask, mode='constant') D = np.take(lut,N) skel[D]=0 return skel.astype(np.bool)
def convolution(radius, image): '''Apply convolution to the image.''' radius_sq = radius ** 2 filt = zeros((radius * 2 + 1, radius * 2 + 1), dtype='int') for i in range(filt.shape[0]): for j in range(filt.shape[1]): if (i - radius) ** 2 + (j - radius) ** 2 < radius_sq: filt[i][j] = 1 return correlate(image, filt.astype(float) / filt.sum(), mode='nearest')
def computeFiberOrientation(v, ds, qs): neg_inf = -999999.0 J_max = np.ones_like(v, dtype='float32') * neg_inf d_max = np.zeros((v.shape[0], v.shape[1], v.shape[2], 3), dtype='float32') for i in range(qs.shape[0]): J = ndimage.correlate(v, qs[i], mode='constant', cval=1.0) update = J > J_max J_max[update] = J[update] d_max[update] = ds[i] return (J_max, d_max)