def setUp(self):
n = 32
L = 8
filters = [
RadialCTFFilter(5, 200, defocus=d, Cs=2.0, alpha=0.1)
for d in np.linspace(1.5e4, 2.5e4, 7)
]
self.dtype = np.float32
self.noise_var = 0.1848
# Initial noise filter to generate noise images.
# Noise variance is set to a value far away that is used to calculate
# covariance matrix and CWF coefficients in order to check the function
# for rebuilding positive definite covariance matrix.
noise_filter = ScalarFilter(dim=2, value=self.noise_var * 0.001)
self.src = Simulation(L,
n,
unique_filters=filters,
dtype=self.dtype,
noise_filter=noise_filter)
self.basis = FFBBasis2D((L, L), dtype=self.dtype)
self.coeff = self.basis.evaluate_t(self.src.images(0, self.src.n))
self.ctf_idx = self.src.filter_indices
self.ctf_fb = [f.fb_mat(self.basis) for f in self.src.unique_filters]
self.cov2d = RotCov2D(self.basis)
self.bcov2d = BatchedRotCov2D(self.src, self.basis, batch_size=7)
def _create_filter(self, noise_variance=None):
"""
:param noise_variance: Noise variance of images
:return: The estimated noise power spectral distribution (PSD) of the images in the form of a filter object.
"""
if noise_variance is None:
logger.info(
f"Determining Noise variance in batches of {self.batchSize}")
noise_variance = self._estimate_noise_variance()
logger.info(f"Noise variance = {noise_variance}")
return ScalarFilter(dim=2, value=noise_variance)
def testImageDownsampleAndWhiten(self):
self.src.downsample(16)
self.src.whiten(noise_filter=ScalarFilter(dim=2, value=0.02450909546680349))
first_whitened_image = self.src.images(0, 1)[0]
self.assertTrue(
np.allclose(
first_whitened_image,
np.load(
os.path.join(DATA_DIR, "starfile_image_0_whitened.npy")
).T, # RCOPT
atol=1e-6,
)
)
def setUp(self):
self.dtype = np.float32
L = 8
n = 32
pixel_size = 5.0 * 65 / L
voltage = 200
defocus_min = 1.5e4
defocus_max = 2.5e4
defocus_ct = 7
self.noise_var = 1.3957e-4
noise_filter = ScalarFilter(dim=2, value=self.noise_var)
unique_filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=2.0, alpha=0.1)
for d in np.linspace(defocus_min, defocus_max, defocus_ct)
]
vols = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype
)
) # RCOPT
vols = vols.downsample((L * np.ones(3, dtype=int))) * 1.0e3
# Since FFBBasis2D doesn't yet implement dtype, we'll set this to double to match its built in types.
sim = Simulation(
n=n,
L=L,
vols=vols,
unique_filters=unique_filters,
offsets=0.0,
amplitudes=1.0,
dtype=self.dtype,
noise_filter=noise_filter,
)
self.basis = FFBBasis2D((L, L), dtype=self.dtype)
self.h_idx = sim.filter_indices
self.h_ctf_fb = [filt.fb_mat(self.basis) for filt in unique_filters]
self.imgs_clean = sim.projections()
self.imgs_ctf_clean = sim.clean_images()
self.imgs_ctf_noise = sim.images(start=0, num=n)
self.cov2d = RotCov2D(self.basis)
self.coeff_clean = self.basis.evaluate_t(self.imgs_clean)
self.coeff = self.basis.evaluate_t(self.imgs_ctf_noise)
def setUp(self):
self.resolution = 16
self.dtype = np.float64
# Create some projections
v = Volume(
np.load(os.path.join(DATA_DIR, "clean70SRibosome_vol.npy")).astype(
self.dtype))
v = v.downsample(self.resolution)
# Clean
self.clean_src = Simulation(
L=self.resolution,
n=321,
vols=v,
dtype=self.dtype,
)
# With Noise
noise_var = 0.01 * np.var(np.sum(v[0], axis=0))
noise_filter = ScalarFilter(dim=2, value=noise_var)
self.noisy_src = Simulation(
L=self.resolution,
n=123,
vols=v,
dtype=self.dtype,
noise_filter=noise_filter,
)
# Set up FFB
# Setup a Basis
self.basis = FFBBasis2D((self.resolution, self.resolution),
dtype=self.dtype)
# Create Basis, use precomputed Basis
self.clean_fspca_basis = FSPCABasis(
self.clean_src, self.basis, noise_var=0
) # Note noise_var assigned zero, skips eigval filtering.
# Ceate another fspca_basis, use autogeneration FFB2D Basis
self.noisy_fspca_basis = FSPCABasis(self.noisy_src)
def testScalarFilter(self):
result = ScalarFilter(value=1.5).evaluate(self.omega)
self.assertEqual(result.shape, (256,))
self.assertTrue(np.allclose(result, np.repeat(1.5, 256)))
logger = logging.getLogger(__name__)
DATA_DIR = os.path.join(os.path.dirname(__file__), "../data/")
logger.info("This script illustrates orientation estimation using "
"synchronization matrix and voting method")
# Set the downsample size of images
img_size = 33
# Set the total number of images generated from the 3D map
num_imgs = 512
# Set the noise variance and build the noise filter
noise_variance = 4e-1
noise_filter = ScalarFilter(dim=2, value=noise_variance)
# Specify the CTF parameters not used for this example
# but necessary for initializing the simulation object
pixel_size = 5 * 65 / img_size # Pixel size of the images (in angstroms)
voltage = 200 # Voltage (in KV)
defocus_min = 1.5e4 # Minimum defocus value (in angstroms)
defocus_max = 2.5e4 # Maximum defocus value (in angstroms)
defocus_ct = 7 # Number of defocus groups
Cs = 2.0 # Spherical aberration
alpha = 0.1 # Amplitude contrast
logger.info("Initialize simulation object and CTF filters.")
# Create CTF filters
ctf_filters = [
RadialCTFFilter(pixel_size, voltage, defocus=d, Cs=2.0, alpha=0.1)