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 __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 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
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
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))
