def correlate_template(self): ''' Correlate template that is already created and configured. ''' fromimage = 'original' if self.__results[fromimage] is None or self.__results['template'] is None: raise RuntimeError('need image %s and template before correlation' % (fromimage,)) edges = self.__results[fromimage] edges = self.maskBlack(edges) template = self.__results['template'] cortype = self.correlation_config['cortype'] corfilt = self.correlation_config['corfilt'] if cortype == 'cross': cc = correlator.cross_correlate(edges, template) elif cortype == 'phase': cc = correlator.phase_correlate(edges, template, zero=False) else: raise RuntimeError('bad correlation type: %s' % (cortype,)) if corfilt is not None: kernel = convolver.gaussian_kernel(*corfilt) self.convolver.setKernel(kernel) cc = self.convolver.convolve(image=cc) self.__update_result('correlation', cc) if self.save_mrc: mrc.write(cc, 'correlation.mrc')
def __init__(self, node): self.node = node ## if tilts are below these thresholds, no need to correct self.alpha_threshold = 0.02 self.bt_threshold = 0.000001 gauss = convolver.gaussian_kernel(2.0) self.filter = convolver.Convolver(kernel=gauss)
def correlate_template(self): fromimage = 'edges' if None in (self.__results[fromimage], self.__results['template']): raise RuntimeError('need image %s and template before correlation' % (fromimage,)) edges = self.__results[fromimage] template = self.__results['template'] cortype = self.correlation_config['cortype'] corfilt = self.correlation_config['corfilt'] if cortype == 'cross': cc = correlator.cross_correlate(edges, template) elif cortype == 'phase': cc = correlator.phase_correlate(edges, template, zero=False) else: raise RuntimeError('bad correlation type: %s' % (cortype,)) cc = numpy.absolute(cc) if corfilt is not None: kernel = convolver.gaussian_kernel(*corfilt) self.edgefinder.setKernel(kernel) cc = self.edgefinder.convolve(image=cc) #cc = imagefun.zscore(smooth) #cc = imagefun.zscore(cc) self.__update_result('correlation', cc) if self.save_mrc: mrc.write(cc, 'correlation.mrc')
def findSquares(self): if self.mosaicimagedata is None: message = 'You must save the current mosaic image before finding squares on it.' self.logger.error(message) return original_image = self.mosaicimagedata['image'] message = 'finding squares' self.logger.info(message) sigma = self.settings['lpf']['sigma'] kernel = convolver.gaussian_kernel(sigma) self.convolver.setKernel(kernel) image = self.convolver.convolve(image=original_image) self.setImage(image, 'Filtered') ## threshold grid bars squares_thresh = self.settings['threshold'] image = imagefun.threshold(image, squares_thresh) self.setImage(image, 'Thresholded') ## find blobs blobs = imagefun.find_blobs(original_image, image, self.settings['blobs']['border'], self.settings['blobs']['max'], self.settings['blobs']['max size'], self.settings['blobs']['min size']) ## use stats to find good ones mean_min = self.settings['blobs']['min mean'] mean_max = self.settings['blobs']['max mean'] std_min = self.settings['blobs']['min stdev'] std_max = self.settings['blobs']['max stdev'] targets = [] prefs = self.storeSquareFinderPrefs() rows, columns = image.shape for blob in blobs: row = blob.stats['center'][0] column = blob.stats['center'][1] mean = blob.stats['mean'] std = blob.stats['stddev'] stats = leginondata.SquareStatsData(prefs=prefs, row=row, column=column, mean=mean, stdev=std) if (mean_min <= mean <= mean_max) and (std_min <= std <= std_max): stats['good'] = True ## create a display target targets.append((column, row)) else: stats['good'] = False self.publish(stats, database=True) ## display them self.setTargets(targets, 'acquisition') message = 'found %s squares' % (len(targets), ) self.logger.info(message)
def find_edges(self): ''' find edges on the original image ''' if self.__results['original'] is None: raise RuntimeError('no original image to find edges on') sourceim = self.__results['original'] filt = self.edges_config['filter'] sigma = self.edges_config['sigma'] ab = self.edges_config['abs'] lpsig = self.edges_config['lpsig'] edgethresh = self.edges_config['thresh'] edgesflag = self.edges_config['edges'] kernel = convolver.gaussian_kernel(lpsig) n = len(kernel) self.edgefinder.setKernel(kernel) smooth = self.edgefinder.convolve(image=sourceim) if not edgesflag: edges = smooth elif filt == 'laplacian3': kernel = convolver.laplacian_kernel3 self.edgefinder.setKernel(kernel) edges = self.edgefinder.convolve(image=smooth) elif filt == 'laplacian5': kernel = convolver.laplacian_kernel5 self.edgefinder.setKernel(kernel) edges = self.edgefinder.convolve(image=smooth) elif filt == 'laplacian-gaussian': kernel = convolver.laplacian_of_gaussian_kernel(n,sigma) self.edgefinder.setKernel(kernel) edges = self.edgefinder.convolve(image=smooth) elif filt == 'sobel': self.edgefinder.setImage(smooth) kernel1 = convolver.sobel_row_kernel kernel2 = convolver.sobel_col_kernel edger = self.edgefinder.convolve(kernel=kernel1) edgec = self.edgefinder.convolve(kernel=kernel2) edges = numpy.hypot(edger,edgec) ## zero the image edge effects edges[:n] = 0 edges[:,:n] = 0 edges[:,-n:] = 0 edges[-n:] = 0 else: raise RuntimeError('no such filter type: %s' % (filt,)) if ab and edgesflag: edges = numpy.absolute(edges) if edgethresh and edgesflag: edges = imagefun.threshold(edges, edgethresh) self.__update_result('edges', edges) if self.save_mrc: mrc.write(edges, 'edges.mrc')
def findSquares(self): if self.mosaicimagedata is None: message = 'You must save the current mosaic image before finding squares on it.' self.logger.error(message) return original_image = self.mosaicimagedata['image'] message = 'finding squares' self.logger.info(message) sigma = self.settings['lpf']['sigma'] kernel = convolver.gaussian_kernel(sigma) self.convolver.setKernel(kernel) image = self.convolver.convolve(image=original_image) self.setImage(image, 'Filtered') ## threshold grid bars squares_thresh = self.settings['threshold'] image = imagefun.threshold(image, squares_thresh) self.setImage(image, 'Thresholded') ## find blobs blobs = imagefun.find_blobs(original_image, image, self.settings['blobs']['border'], self.settings['blobs']['max'], self.settings['blobs']['max size'], self.settings['blobs']['min size']) ## use stats to find good ones mean_min = self.settings['blobs']['min mean'] mean_max = self.settings['blobs']['max mean'] std_min = self.settings['blobs']['min stdev'] std_max = self.settings['blobs']['max stdev'] targets = [] prefs = self.storeSquareFinderPrefs() rows, columns = image.shape for blob in blobs: row = blob.stats['center'][0] column = blob.stats['center'][1] mean = blob.stats['mean'] std = blob.stats['stddev'] stats = leginondata.SquareStatsData(prefs=prefs, row=row, column=column, mean=mean, stdev=std) if (mean_min <= mean <= mean_max) and (std_min <= std <= std_max): stats['good'] = True ## create a display target targets.append((column,row)) else: stats['good'] = False self.publish(stats, database=True) ## display them self.setTargets(targets, 'acquisition') message = 'found %s squares' % (len(targets),) self.logger.info(message)
def filterImg(img, apix, bin, rad): # low pass filter image to res resolution if rad == 0: print " ... skipping low pass filter" return (img) else: print " ... performing low pass filter" sigma = float(rad) / apix / 3.0 / float(bin) kernel = convolver.gaussian_kernel(sigma) c = convolver.Convolver() return (c.convolve(image=img, kernel=kernel))
def filterImg(img,apix,bin,rad): # low pass filter image to res resolution if rad==0: print " ... skipping low pass filter" return(img) else: print " ... performing low pass filter" sigma=float(rad)/apix/3.0/float(bin) kernel=convolver.gaussian_kernel(sigma) c=convolver.Convolver() return(c.convolve(image=img,kernel=kernel))
def _process(self, input): sigma = self.sigma.get() kernel = convolver.gaussian_kernel(sigma) self.convolver.setKernel(kernel) return self.outputclass(self.convolver.convolve(image=input.image))
def gaussian(shape, sigma, n=5): gk = convolver.gaussian_kernel(n, sigma) return kernel_image(shape, gk)
def lowPassFilter(self, image, sigma, size=9): k = convolver.gaussian_kernel(size, sigma) smooth = self.conv.convolve(image=image, kernel=k) return smooth