def _init_initial_support(self):
if not self._initial_support_dirty:
self._log("Initial support already initialised.","DEBUG")
return
for img in [self._sp_initial_support,self._sp_initial_support_sh]:
if img is not None:
spimage.sp_image_free(img)
self._sp_initial_support = spimage.sp_image_alloc(self._Ny,self._Nx,1)
if "radius" in self._initial_support_config or "area" in self._initial_support_config:
X,Y = np.meshgrid(np.arange(self._Nx),np.arange(self._Ny))
X = X-(self._Nx-1)/2.
Y = Y-(self._Ny-1)/2.
R = np.sqrt(X**2 + Y**2)
self._phaser_dirty = True
if "radius" in self._initial_support_config:
r = self._initial_support_config["radius"]
else:
r = np.sqrt( self._initial_support_config["area"] * self._Nx * self._Ny / np.pi )
self._sp_initial_support.image[:] = np.float32(np.fft.fftshift(R) < r)
else:
self._phaser_dirty = True
S = self._initial_support_config["support_mask"]
self.sep_initial_support.image[:] = np.float32(S)
self._initial_support_dirty = False
self._log("Initial support initialised.","DEBUG")
def _clear_amplitudes(self):
for img in [self._sp_amplitudes]:
if img is not None:
spimage.sp_image_free(img)
self._amplitudes = None
self._sp_amplitudes = None
self._amplitudes_dirty = True
def intensities_array_to_h5(img0,msk0,cx=None,cy=None,cropLength=None,save_to_file=None):
import spimage,imgtools
Nx = img0.shape[1]
Ny = img0.shape[0]
img = img0
msk = msk0
if cropLength != None:
img = imgtools.crop(img0,cropLength,center=[cy,cx])
msk = imgtools.crop(msk0,cropLength,center=[cy,cx])
Nx = cropLength
Ny = cropLength
elif cx != None and cy != None:
img = imgtools.recenter(img0,cx,cy)
msk = imgtools.recenter(msk0,cx,cy)
I = spimage.sp_image_alloc(Nx,Ny,1)
I.image[:,:] = img[:,:]
I.mask[:,:] = msk[:,:]
I2 = spimage.sp_image_shift(I)
I2.shifted = 0
I2.phased = 0
spimage.sp_image_free(I)
if save_to_file != None:
spimage.sp_image_write(I2,save_to_file,0)
else:
return I2
def _clear_initial_support(self):
for img in [self._sp_initial_support,self._sp_initial_support_sh]:
if img is not None:
spimage.sp_image_free(img)
self._sp_initial_support = None
self._sp_initial_support_sh = None
self._initial_support_config = None
self._initial_support_dirty = True
def to_png(input_dir, output_dir, plot_setup):
#color,shift_flag,support_flag = evaluate_arguments(arguments)
files = read_files(input_dir)
shift_function = get_shift_function(plot_setup.get_shift())
support_function = get_support_function(plot_setup.get_mask())
for f in files:
img = spimage.sp_image_read(f,0)
support_function(img)
img = sp_image_shift(img)
spimage.sp_image_write(img,output_dir+"/"+f[:-2]+"png",plot_setup.get_color())
spimage.sp_image_free(img)
def to_png(*arguments):
color,shift_flag,support_flag = evaluate_arguments(arguments)
files = read_files()
shift_function = get_shift_function(shift_flag)
support_function = get_support_function(support_flag)
for f in files:
img = spimage.sp_image_read(f,0)
support_function(img)
img = sp_image_shift(img)
spimage.sp_image_write(img,f[:-2]+"png",color)
spimage.sp_image_free(img)
def find_center_blurred(img, msk, x0=0, y0=0, threshold=None, blur_radius=4., dmax=5):
"""
Find the center using blurred version of 'pixelwise' method.
usage:
======
x,y = find_center_blurred(img, msk, x0=0, y0=0, threshold=None, blur_radius=4, dmax=5)
"""
if threshold is None: threshold = img.min()
I = spimage.sp_image_alloc(img.shape[1],img.shape[0],1)
I.image[:] = img * (img >= threshold)
I.mask[:] = msk[:]
I.detector.image_center[:] = np.array([center_to_pos(x0,img.shape[1]),
center_to_pos(y0,img.shape[0]), 0 ])
kernel = spimage.sp_gaussian_kernel(float(blur_radius),int(blur_radius*8+1),int(blur_radius*8+1),1)
c = spimage.sp_image_convolute_with_mask(I,kernel,np.array([1,1,1]).astype(np.int32))
ds = spimage.sp_image_alloc(int(img.shape[1]/4),int(img.shape[0]/4),1)
ds.image[:] = c.image[:-3:4,:-3:4]
ds.mask[:] = c.mask[:-3:4,:-3:4]
ds.detector.image_center[:] = c.detector.image_center[:] / 4.0
spimage.sp_find_center_refine_minimal_mask(ds, int(1+dmax/4), 0)
c.detector.image_center[:] = ds.detector.image_center[:] * 4.0
spimage.sp_image_free(ds)
score = spimage.sp_find_center_refine_minimal_mask(c, 4, 0)
x = pos_to_center(c.detector.image_center[0],img.shape[1])
y = pos_to_center(c.detector.image_center[1],img.shape[0])
spimage.sp_image_free(I)
spimage.sp_image_free(kernel)
spimage.sp_image_free(c)
return (x,y,score)
def find_center_blurred(img, msk, x0=0, y0=0, threshold=None, blur_radius=4., dmax=5):
"""
Find the center using blurred version of 'pixelwise' method.
usage:
======
x,y = find_center_blurred(img, msk, x0=0, y0=0, threshold=None, blur_radius=4, dmax=5)
"""
if threshold is None: threshold = img.min()
I = spimage.sp_image_alloc(img.shape[1],img.shape[0],1)
I.image[:] = img * (img >= threshold)
I.mask[:] = msk[:]
I.detector.image_center[:] = np.array([center_to_pos(x0,img.shape[1]),
center_to_pos(y0,img.shape[0]), 0 ])
kernel = spimage.sp_gaussian_kernel(float(blur_radius),int(blur_radius*8+1),int(blur_radius*8+1),1)
c = spimage.sp_image_convolute_with_mask(I,kernel,np.array([1,1,1]).astype(np.int32))
ds = spimage.sp_image_alloc(img.shape[1]/4,img.shape[0]/4,1)
ds.image[:] = c.image[:-3:4,:-3:4]
ds.mask[:] = c.mask[:-3:4,:-3:4]
ds.detector.image_center[:] = c.detector.image_center[:] / 4.0
spimage.sp_find_center_refine_minimal_mask(ds, int(1+dmax/4), 0)
c.detector.image_center[:] = ds.detector.image_center[:] * 4.0
spimage.sp_image_free(ds)
score = spimage.sp_find_center_refine_minimal_mask(c, 4, 0)
x = pos_to_center(c.detector.image_center[0],img.shape[1])
y = pos_to_center(c.detector.image_center[1],img.shape[0])
spimage.sp_image_free(I)
spimage.sp_image_free(kernel)
spimage.sp_image_free(c)
return (x,y,score)
def pnccd_to_image(infile, outfile):
try:
f = h5py.File(infile)
except:
raise IOError("Can't read %s. It may not be a pnCCD file." % filename)
i1 = f.keys().index("data")
i2 = f.values()[i1].keys().index("data1")
data = f.values()[i1].values()[i2].value
img = spimage.sp_image_alloc(pylab.shape(data)[0], pylab.shape(data)[1], 1)
img.image[:, :] = data[:, :]
spimage.sp_image_write(img, outfile, 0)
spimage.sp_image_free(img)
def _init_initial_support(self):
if not self._initial_support_dirty:
self._log("Initial support already initialised.","DEBUG")
return
for img in [self._sp_initial_support,self._sp_initial_support_sh]:
if img is not None:
spimage.sp_image_free(img)
A = self._amplitudes
if len(A.shape) == 2:
self._sp_initial_support = spimage.sp_image_alloc(self._Ny,self._Nx,1)
if "radius" in self._initial_support_config or "area" in self._initial_support_config:
X,Y = np.meshgrid(np.arange(self._Nx),np.arange(self._Ny))
X = X-(self._Nx-1)/2.
Y = Y-(self._Ny-1)/2.
R = np.sqrt(X**2 + Y**2)
self._phaser_dirty = True
if "radius" in self._initial_support_config:
r = self._initial_support_config["radius"]
else:
r = np.sqrt( self._initial_support_config["area"] * self._Nx * self._Ny / np.pi )
self._sp_initial_support.image[:] = np.float32(np.fft.fftshift(R) < r)
else:
self._phaser_dirty = True
S = self._initial_support_config["support_mask"]
self._sp_initial_support.image[:] = np.float32(S)
self._initial_support_dirty = False
self._log("Initial support initialised.","DEBUG")
if len(A.shape) == 3:
self._sp_initial_support = spimage.sp_image_alloc(self._Nz, self._Ny,self._Nx)
if "radius" in self._initial_support_config or "area" in self._initial_support_config:
X,Y,Z = np.meshgrid(np.arange(self._Nx),np.arange(self._Ny),np.arange(self._Nz))
X = X-(self._Nx-1)/2.
Y = Y-(self._Ny-1)/2.
Z = Z-(self._Nz-1)/2.
R = np.sqrt(X**2 + Y**2 + Z**2)
self._phaser_dirty = True
if "radius" in self._initial_support_config:
r = self._initial_support_config["radius"]
else:
r = np.sqrt( self._initial_support_config["area"] * self._Nx * self._Ny * self._Nz / np.pi )
self._sp_initial_support.image[:] = np.float32(np.fft.fftshift(R) < r)
else:
self._phaser_dirty = True
S = self._initial_support_config["support_mask"]
self.sep_initial_support.image[:] = np.float32(S)
self._initial_support_dirty = False
self._log("Initial support initialised.","DEBUG")
def center_image(filename, outfile, sigma=3):
"""Finds a localized strong object and puts it in the center. The
sigma variable describes the size of the object"""
print("foo")
if not os.path.isfile(filename):
raise IOError("Can not find file {0}".format(filename))
img = spimage.sp_image_read(filename, 0)
x = (numpy.arange(img.image.shape[0], dtype='float64') -
img.image.shape[0] / 2. + 0.5)
y = (numpy.arange(img.image.shape[1], dtype='float64') -
img.image.shape[1] / 2. + 0.5)
z = (numpy.arange(img.image.shape[2], dtype='float64') -
img.image.shape[2] / 2. + 0.5)
kernel = numpy.exp(-(x[:, numpy.newaxis, numpy.newaxis]**2 +
y[numpy.newaxis, :, numpy.newaxis]**2 +
y[numpy.newaxis, numpy.newaxis, :]**2) / 2.0 /
sigma**2)
img_ft = numpy.fft.fft2(numpy.fft.fftshift(img.image))
kernel_ft = numpy.fft.fft2(numpy.fft.fftshift(kernel))
kernel_ft *= numpy.conj(img_ft)
bt = numpy.fft.ifft2(kernel_ft)
min_v = 0.
min_x = 0
min_y = 0
min_z = 0
for x in range(bt.shape[0]):
for y in range(bt.shape[1]):
for z in range(bt.shape[2]):
if abs(bt[z, y, x]) > min_v:
min_v = abs(bt[z, y, x])
min_x = x
min_y = y
min_z = z
print(min_x, min_y, min_z)
spimage.sp_image_translate(img, -(-min_z + bt.shape[0] // 2),
-(-min_y + bt.shape[1] // 2),
-(-min_x + bt.shape[2] // 2),
spimage.SP_TRANSLATE_WRAP_AROUND)
shift = img
spimage.sp_image_write(shift, outfile, 0)
spimage.sp_image_free(img)
def find_center_pixelwise_fast(img, msk, x0=0, y0=0, dmax=5, rmax=None):
"""
Find center of diffraction pattern using a pixelwise comparison of centry-symmetric pixels.
This is a faster C implementation.
usage:
======
x,y = find_center_pixelwise_fast(img, msk, x0, y0, dmax=5, rmax=None)
"""
if rmax is not None: msk &= (spimage.rgrid(msk.shape, (x0,y0)) < rmax)
I = spimage.sp_image_alloc(int(np.ceil(img.shape[1])), int(np.ceil(img.shape[0])), 1)
I.image[:] = img
I.mask[:] = msk
I.detector.image_center[:] = np.array([center_to_pos(x0,img.shape[1]), center_to_pos(y0,img.shape[0]), 0 ])
success = spimage.sp_find_center_refine(I, dmax, 0, None)
x = pos_to_center(I.detector.image_center[0],img.shape[1])
y = pos_to_center(I.detector.image_center[1],img.shape[0])
spimage.sp_image_free(I)
return (x,y,success)
def find_center_pixelwise_fast(img, msk, x0=0, y0=0, dmax=5, rmax=None):
"""
Find center of diffraction pattern using a pixelwise comparison of centry-symmetric pixels.
This is a faster C implementation.
usage:
======
x,y = find_center_pixelwise_fast(img, msk, x0, y0, dmax=5, rmax=None)
"""
if rmax is not None: msk &= (spimage.rgrid(msk.shape, (x0,y0)) < rmax)
I = spimage.sp_image_alloc(int(np.ceil(img.shape[1])), int(np.ceil(img.shape[0])), 1)
I.image[:] = img
I.mask[:] = msk
I.detector.image_center[:] = np.array([center_to_pos(x0,img.shape[1]), center_to_pos(y0,img.shape[0]), 0 ])
success = spimage.sp_find_center_refine(I, dmax, 0, None)
x = pos_to_center(I.detector.image_center[0],img.shape[1])
y = pos_to_center(I.detector.image_center[1],img.shape[0])
spimage.sp_image_free(I)
return (x,y,success)
def _init_amplitudes(self):
if not self._amplitudes_dirty:
self._log("Amplitudes already initialised.","DEBUG")
return
A = self._amplitudes
self._Nx = A.shape[1]
self._Ny = A.shape[0]
if self._mask is not None:
M = self._mask.copy()
else:
M = np.ones(shape=A.shape,dtype="bool")
for img in [self._sp_amplitudes]:
if img is not None:
spimage.sp_image_free(img)
self._sp_amplitudes = spimage.sp_image_alloc(A.shape[0],A.shape[1],1)
self._sp_amplitudes.image[:,:] = np.float32(A[:,:])
self._sp_amplitudes.mask[:,:] = np.int32(M[:,:])
self._sp_amplitudes.scaled = 1
self._sp_amplitudes.phased = 0
self._amplitudes_dirty = False
self._log("Amplitudes initialised.","DEBUG")
def _init_amplitudes(self):
if not self._amplitudes_dirty:
self._log("Amplitudes already initialised.","DEBUG")
return
A = self._amplitudes
if len(A.shape) == 2:
self._Nx = A.shape[1]
self._Ny = A.shape[0]
if self._mask is not None:
M = self._mask.copy()
else:
M = np.ones(shape=A.shape,dtype="bool")
for img in [self._sp_amplitudes]:
if img is not None:
spimage.sp_image_free(img)
self._sp_amplitudes = spimage.sp_image_alloc(A.shape[0],A.shape[1],1)
self._sp_amplitudes.image[:,:] = np.float32(A[:,:])
self._sp_amplitudes.mask[:,:] = np.int32(M[:,:])
self._sp_amplitudes.scaled = 1
self._sp_amplitudes.phased = 0
self._amplitudes_dirty = False
self._log("Amplitudes initialised.","DEBUG")
if len(A.shape) == 3:
self._Nx = A.shape[2]
self._Ny = A.shape[1]
self._Nz = A.shape[0]
if self._mask is not None:
M = self._mask.copy()
else:
M = np.ones(shape=A.shape,dtype="bool")
for img in [self._sp_amplitudes]:
if img is not None:
spimage.sp_image_free(img)
self._sp_amplitudes = spimage.sp_image_alloc(A.shape[0],A.shape[1],A.shape[2])
self._sp_amplitudes.image[:,:,:] = np.float32(A[:,:,:])
self._sp_amplitudes.mask[:,:,:] = np.int32(M[:,:,:])
self._sp_amplitudes.scaled = 1
self._sp_amplitudes.phased = 0
self._amplitudes_dirty = False
self._log("Amplitudes initialised.","DEBUG")
def crop_image(in_file, out_file, side, center=None):
"""Function to crop an h5 image and pad with zeros around it"""
img = spimage.sp_image_read(in_file, 0)
if not center:
center = img.detector.image_center[:2]
shifted = 0
if img.shifted:
shifted = 1
img = spimage.sp_image_shift(img)
print "shifted = ", shifted
# cropped = spimage.rectangle_crop(img,lowX,lowY,highX,highY)
cropped = spimage.sp_image_alloc(side, side, 1)
cropped.image[:, :] = image_manipulation.crop_and_pad(img.image, center, side)
cropped.mask[:, :] = image_manipulation.crop_and_pad(img.mask, center, side)
print "did crop"
if shifted:
cropped = spimage.sp_image_shift(cropped)
print "shifted (or not)"
print "write ", out_file
# print "orientation = ", cropped.detector.orientation
# print spimage.sp_3matrix_get(cropped.detector.orientation,0,0,0)
spimage.sp_image_write(cropped, out_file, 16)
spimage.sp_image_free(img)
spimage.sp_image_free(cropped)
print "end"
def process(self, f):
img = spimage.sp_image_read(f, 0)
img = self.process_function(img)
output_file = self.out_dir + "/" + f[:-2] + "png"
spimage.sp_image_write(img, output_file, self.color)
spimage.sp_image_free(img)
def real_space_residual_all_iterations(reference_file=None,
support_file=None,
iteration=None,
mode='absolute',
normalize_ref_to_model=False,
skip='None',
model_cf=None):
if mode == 'absolute': f = np.absolute
elif mode == 'angle': f = np.angle
elif mode == 'real': f = np.real
elif mode == 'imag': f = np.imag
if os.getcwd().startswith('/mnt'):
models = [
i + '/output_mnt/' for i in os.listdir('.')
if i.startswith('run_') and not i.startswith(skip)
]
else:
models = [
i + '/output/' for i in os.listdir('.')
if i.startswith('run_') and not i.startswith(skip)
]
models.sort()
files_dir_0 = models[0]
print files_dir_0
if iteration == None:
iteration = return_last_iteration_integer(files_dir_0)
print iteration
if support_file != None:
support_sp = spimage.sp_image_read(support_file, 0)
support_arr = real(support_sp.image[:])
elif model_cf != None:
prtf_dir = [d for d in os.listdir('.') if d.startswith('prtf')]
avg_model = f(
spimage.sp_image_read(
os.path.join(prtf_dir[0], 'PRTF-avg_image.h5'), 0).image[:])
support_arr = np.zeros_like(avg_model)
support_arr[(avg_model / avg_model.max()) >= model_cf] = 1
print 'using {} pixels'.format(np.sum(support_arr))
else:
print models[0]
support_sp = spimage.sp_image_read(
files_dir_0 + 'support_%04d.h5' % iteration, 0)
support_arr = real(support_sp.image[:])
if reference_file != None:
reference_sp = spimage.sp_image_read(reference_file, 0)
reference = f(reference_sp.image[:])
else:
reference = support_arr.copy()
rscs = []
for m in models:
try:
model_sp = spimage.sp_image_read(m + 'model_%04d.h5' % iteration,
0)
model = f(model_sp.image[:])
print m
rscs.append(
stuff.real_space_residual(reference,
model,
support=support_arr,
normalize=True))
spimage.sp_image_free(model_sp)
del model
except AttributeError:
print 'Error: {} does not exist'.format(m)
return rscs
def shift_function(img):
ret = spimage.sp_image_shift(img)
spimage.sp_image_free(img)
return ret
def to_png(*arguments):
if len(arguments) <= 0:
print("""
This program converts all h5 files in the curren directory to png.
Usage: python_script_new_to_png [colorscale]
Colorscales:
Jet
Gray
PosNeg
InvertedPosNeg
Phase
InvertedPhase
Log (can be combined with the others)
Shift (can be combined with the others)
Support
""")
return
elif not (isinstance(arguments, list) or isinstance(arguments, tuple)):
print("function to_png takes must have a list or string input")
return
files = os.listdir('.')
expr = re.compile('.h5$')
h5_files = list(filter(expr.search, files))
expr = re.compile('.png$')
png_files = list(filter(expr.search, files))
files = [f for f in h5_files if f[:-2]+"png" not in png_files]
files.sort()
print("Converting %d files" % len(files))
log_flag = 0
shift_flag = 0
support_flag = 0
color = 16
for flag in arguments:
if flag == 'PosNeg':
color = 8192
elif flag == 'InvertedPosNeg':
color = 16384
elif flag == 'Phase':
color = 256
elif flag == 'InvertedPhase':
color = 4096
elif flag == 'Jet':
color = 16
elif flag == 'Gray':
color = 1
elif flag == 'Log':
log_flag = 1
elif flag == 'Shift':
shift_flag = 1
elif flag == 'Support':
support_flag = 1
else:
print("unknown flag %s" % flag)
if log_flag == 1:
color += 128
# for f in files:
# img = spimage.sp_image_read(f[:-1],0)
if shift_flag:
def shift_function(img):
ret = spimage.sp_image_shift(img)
spimage.sp_image_free(img)
return ret
else:
def shift_function(img):
return img
if support_flag:
for f in files:
img = spimage.sp_image_read(f, 0)
spimage.sp_image_mask_to_image(img, img)
img = shift_function(img)
spimage.sp_image_write(img, f[:-2]+"png", color)
spimage.sp_image_free(img)
else:
for f in files:
img = spimage.sp_image_read(f, 0)
img = shift_function(img)
spimage.sp_image_write(img, f[:-2]+"png", color)
spimage.sp_image_free(img)
def process(self, f):
#for f in files:
img = spimage.sp_image_read(f,0)
img = self.process_function(img)
spimage.sp_image_write(img,f[:-2]+"png",self.color)
spimage.sp_image_free(img)
def to_png(*arguments):
if len(arguments) <= 0:
print """
This program converts all h5 files in the curren directory to png.
Usage: python_script_new_to_png [colorscale]
Colorscales:
Jet
Gray
PosNeg
InvertedPosNeg
Phase
InvertedPhase
Log (can be combined with the others)
Shift (can be combined with the others)
Support
"""
return
elif not (isinstance(arguments,list) or isinstance(arguments,tuple)):
print "function to_png takes must have a list or string input"
return
#l = os.popen('ls').readlines()
l = os.listdir('.')
expr = re.compile('.h5$')
h5_files = filter(expr.search,l)
expr = re.compile('.png$')
png_files = filter(expr.search,l)
files = [f for f in h5_files if f[:-2]+"png" not in png_files]
files.sort()
print "Converting %d files" % len(files)
log_flag = 0
shift_flag = 0
support_flag = 0
color = 16
for flag in arguments:
if flag == 'PosNeg':
color = 8192
elif flag == 'InvertedPosNeg':
color = 16384
elif flag == 'Phase':
color = 256
elif flag == 'InvertedPhase':
color = 4096
elif flag == 'Jet':
color = 16
elif flag == 'Gray':
color = 1
elif flag == 'Log':
log_flag = 1
elif flag == 'Shift':
shift_flag = 1
elif flag == 'Support':
support_flag = 1
else:
print "unknown flag %s" % flag
if log_flag == 1:
color += 128
# for f in files:
# img = spimage.sp_image_read(f[:-1],0)
def shift_function(img):
return img
if shift_flag:
def shift_function(img):
ret = spimage.sp_image_shift(img)
spimage.sp_image_free(img)
return ret
if support_flag:
for f in files:
img = spimage.sp_image_read(f,0)
spimage.sp_image_mask_to_image(img,img)
img = shift_function(img)
spimage.sp_image_write(img,f[:-2]+"png",color)
spimage.sp_image_free(img)
else:
for f in files:
img = spimage.sp_image_read(f,0)
img = shift_function(img)
spimage.sp_image_write(img,f[:-2]+"png",color)
spimage.sp_image_free(img)
def shift_function(img):
ret = spimage.sp_image_shift(img)
spimage.sp_image_free(img)
return ret
def process(self, f):
img = spimage.sp_image_read(f,0)
img = self.process_function(img)
spimage.sp_image_write(img,self.out_dir+"/"+f[:-2]+"png",self.color)
spimage.sp_image_free(img)
def prtf(images_rs,supports,translate=True,enantio=True,full_out=False):
"""
NOTE: For using the enantio option, the images need to be centered in fourier space (no phase ramp in real space)
"""
S = images_rs.shape
s = list(S)
N = s.pop(0)
s = tuple(s)
image0_rs = images_rs[0]
image0_fs = numpy.fft.fftn(image0_rs)
sp_image0_rs = numpy_array_to_image(image0_rs,supports[0])
sp_image0_fs = numpy_array_to_image(image0_fs)
sp_amp_fs = spimage.sp_image_duplicate(sp_image0_fs,spimage.SP_COPY_ALL)
spimage.sp_image_dephase(sp_amp_fs)
spimage.sp_image_free(sp_image0_rs)
spimage.sp_image_free(sp_image0_fs)
sum_fs = image0_fs.copy()
sum_fs[abs(sum_fs) > 0.] /= abs(sum_fs[abs(sum_fs) > 0.])
sp_sum_fs = numpy_array_to_image(sum_fs)
zeros = numpy.zeros(shape=s,dtype="int")
zeros[abs(sum_fs) <= 0.] = 1
sp_avg_img = numpy_array_to_image(image0_rs)
avg_msk = numpy.zeros(shape=s,dtype="float")
images_rs_super = numpy.zeros(shape=S,dtype="complex128")
images_rs_super[0,:] = image0_rs[:]
masks_rs_super = numpy.zeros(shape=S,dtype="bool")
masks_rs_super[0,:] = supports[0,:]
for i,img,sup in zip(range(1,N),images_rs[1:],supports[1:]):
# Initialize image
sp_img = numpy_array_to_image(img,sup)
# Translate and enantio matching
if translate:
spimage.sp_image_superimpose(sp_avg_img,sp_img, spimage.SpEnantiomorph if enantio else 0)
spimage.sp_image_phase_match(sp_avg_img,sp_img,2)
spimage.sp_image_add(sp_avg_img,sp_img)
if sp_img.mask.sum() > 0:
avg_msk[sp_img.mask == 0] += 1
# Cache image and support
images_rs_super[i,:] = sp_img.image[:]
masks_rs_super[i,:] = sp_img.mask[:]
# Add amplitudes
sp_tmp = spimage.sp_image_fftw3(sp_img)
sp_tmpamp = spimage.sp_image_duplicate(sp_tmp,spimage.SP_COPY_ALL)
spimage.sp_image_dephase(sp_tmpamp);
spimage.sp_image_add(sp_amp_fs,sp_tmpamp)
# Count zeros
positive = abs(sp_tmp.image) > 0.
sp_tmp.image[positive] /= abs(sp_tmp.image)[positive]
zeros += (positive == False)
spimage.sp_image_add(sp_sum_fs,sp_tmp)
spimage.sp_image_free(sp_img)
spimage.sp_image_free(sp_tmp)
spimage.sp_image_free(sp_tmpamp)
sp_prtf = spimage.sp_image_duplicate(sp_sum_fs,spimage.SP_COPY_DATA|spimage.SP_COPY_MASK)
sp_prtf.image[:] /= N
sp_prtf.image[zeros > 0] = 0.
spimage.sp_image_dephase(sp_prtf)
avg_img = sp_avg_img.image[:].copy()
avg_sup = avg_msk > 0
prtf = abs(sp_prtf.image[:]).copy()
prtf = numpy.fft.fftshift(prtf)
for sp_i in [sp_prtf,sp_avg_img,sp_amp_fs,sp_sum_fs]:
spimage.sp_image_free(sp_i)
out = {}
out["prtf"] = prtf
out["super_image"] = avg_img
if full_out:
out["prtf_r"] = spimage.radial_mean(prtf,cx=s[1]/2,cy=s[0]/2)
out["super_mask"] = avg_sup
out["images"] = images_rs_super
out["masks"] = masks_rs_super
return out
def prtf(images_rs, supports, translate=True, enantio=True, full_out=False):
"""
NOTE: For using the enantio option, the images need to be centered in fourier space (no phase ramp in real space)
"""
S = images_rs.shape
s = list(S)
N = s.pop(0)
s = tuple(s)
image0_rs = images_rs[0]
image0_fs = numpy.fft.fftn(image0_rs)
sp_image0_rs = numpy_array_to_image(image0_rs, supports[0])
sp_image0_fs = numpy_array_to_image(image0_fs)
sp_amp_fs = spimage.sp_image_duplicate(sp_image0_fs, spimage.SP_COPY_ALL)
spimage.sp_image_dephase(sp_amp_fs)
spimage.sp_image_free(sp_image0_rs)
spimage.sp_image_free(sp_image0_fs)
sum_fs = image0_fs.copy()
sum_fs[abs(sum_fs) > 0.] /= abs(sum_fs[abs(sum_fs) > 0.])
sp_sum_fs = numpy_array_to_image(sum_fs)
zeros = numpy.zeros(shape=s, dtype="int")
zeros[abs(sum_fs) <= 0.] = 1
sp_avg_img = numpy_array_to_image(image0_rs)
avg_msk = numpy.zeros(shape=s, dtype="float")
images_rs_super = numpy.zeros(shape=S, dtype="complex128")
images_rs_super[0, :] = image0_rs[:]
masks_rs_super = numpy.zeros(shape=S, dtype="bool")
masks_rs_super[0, :] = supports[0, :]
for i, img, sup in zip(range(1, N), images_rs[1:], supports[1:]):
# Initialize image
sp_img = numpy_array_to_image(img, sup)
# Translate and enantio matching
if translate:
spimage.sp_image_superimpose(
sp_avg_img, sp_img, spimage.SpEnantiomorph if enantio else 0)
spimage.sp_image_phase_match(sp_avg_img, sp_img, 2)
spimage.sp_image_add(sp_avg_img, sp_img)
if sp_img.mask.sum() > 0:
avg_msk[sp_img.mask == 0] += 1
# Cache image and support
images_rs_super[i, :] = sp_img.image[:]
masks_rs_super[i, :] = sp_img.mask[:]
# Add amplitudes
sp_tmp = spimage.sp_image_fftw3(sp_img)
sp_tmpamp = spimage.sp_image_duplicate(sp_tmp, spimage.SP_COPY_ALL)
spimage.sp_image_dephase(sp_tmpamp)
spimage.sp_image_add(sp_amp_fs, sp_tmpamp)
# Count zeros
positive = abs(sp_tmp.image) > 0.
sp_tmp.image[positive] /= abs(sp_tmp.image)[positive]
zeros += (positive == False)
spimage.sp_image_add(sp_sum_fs, sp_tmp)
spimage.sp_image_free(sp_img)
spimage.sp_image_free(sp_tmp)
spimage.sp_image_free(sp_tmpamp)
sp_prtf = spimage.sp_image_duplicate(
sp_sum_fs, spimage.SP_COPY_DATA | spimage.SP_COPY_MASK)
sp_prtf.image[:] /= N
sp_prtf.image[zeros > 0] = 0.
spimage.sp_image_dephase(sp_prtf)
avg_img = sp_avg_img.image[:].copy()
avg_sup = avg_msk > 0
prtf = abs(sp_prtf.image[:]).copy()
prtf = numpy.fft.fftshift(prtf)
for sp_i in [sp_prtf, sp_avg_img, sp_amp_fs, sp_sum_fs]:
spimage.sp_image_free(sp_i)
out = {}
out["prtf"] = prtf
out["super_image"] = avg_img
if full_out:
out["prtf_r"] = spimage.radial_mean(prtf, cx=s[1] / 2, cy=s[0] / 2)
out["super_mask"] = avg_sup
out["images"] = images_rs_super
out["masks"] = masks_rs_super
return out
# img.image[img.image < 0.0] = 0.0
options = ["shift", "log", "mask"]
for o in sys.argv:
if o in options:
if o.lower() == "shift":
shift = True
if o.lower() == "log":
log = True
if o.lower() == "mask":
plot_mask = True
if shift:
img_s = spimage.sp_image_shift(img)
spimage.sp_image_free(img)
img = img_s
if plot_mask:
plot_array = img.mask
else:
plot_array = abs(img.image)
if log:
s = mlab.pipeline.scalar_field(log10(0.001 * max(plot_array.flatten()) + plot_array))
else:
s = mlab.pipeline.scalar_field(plot_array)
# mlab.figure(size=(1000,900))
mlab.pipeline.image_plane_widget(s, plane_orientation="x_axes", slice_index=shape(img.image)[0] / 2)
