Relion >= 3.1 offsets convention: _rlnOriginX(Y)Angst

gallery/tutorials/tutorials/basic_image_array.py

@@ -127,7 +127,7 @@ def noise_function(x, y):
 # The implementation of batching for memory management
 # would be managed behind the scenes for you.
 
-imgs_src = ArrayImageSource(imgs_with_noise)
+imgs_src = ArrayImageSource(imgs_with_noise, pixel_size=1.0)
 
 # We'll copy the orginals for comparison later, before we process them further.
 noisy_imgs_copy = imgs_src.images[:n_imgs].asnumpy()

gallery/tutorials/tutorials/class_averaging.py

@@ -91,7 +91,7 @@
 
 # So now that we have cooked up an example dataset, lets create an
 # ASPIRE source
-src = ArrayImageSource(example_array)
+src = ArrayImageSource(example_array, pixel_size=1.0)
 
 # Let's peek at the images to make sure they're shuffled up nicely
 src.images[:10].show()

gallery/tutorials/tutorials/micrograph_source.py

@@ -387,7 +387,11 @@
 
 # %%
 
-img_src = CentersCoordinateSource(results, src.particle_box_size)
+img_src = CentersCoordinateSource(
+    results,
+    src.pixel_size,
+    src.particle_box_size,
+)
 # Show the first five images from the image source.
 img_src.images[:3].show()
 

gallery/tutorials/tutorials/relion_projection_interop.py

@@ -22,7 +22,7 @@
 # We load the Relion projections as a ``RelionSource`` and view the images.
 
 starfile = os.path.join(os.path.dirname(os.getcwd()), "data", "rln_proj_65.star")
-rln_src = RelionSource(starfile)
+rln_src = RelionSource(starfile, pixel_size=1)
 rln_src.images[:].show(colorbar=False)
 
 # %%

src/aspire/commands/extract_particles.py

@@ -29,6 +29,12 @@
     required=True,
     help="Path to starfile of the particle stack to be created",
 )
+@click.option(
+    "--pixel_size",
+    default=None,
+    type=float,
+    help="Pixel size of micrograph in angstroms.",
+)
 @click.option(
     "--particle_size",
     default=None,
@@ -77,6 +83,7 @@ def extract_particles(
     mrc_paths,
     coord_paths,
     starfile_out,
+    pixel_size,
     particle_size,
     centers,
     downsample,
@@ -133,11 +140,13 @@ def extract_particles(
             )
         src = CentersCoordinateSource(
             files,
+            pixel_size,
             particle_size=particle_size,
         )
     else:
         src = BoxesCoordinateSource(
             files,
+            pixel_size,
             particle_size=particle_size,
         )
 

src/aspire/commands/orient3d.py

@@ -23,7 +23,7 @@
     help="Path to output STAR file relative to data folder",
 )
 @click.option(
-    "--pixel_size", default=1, type=float, help="Pixel size of images in STAR file"
+    "--pixel_size", default=None, type=float, help="Pixel size of images in STAR file"
 )
 @click.option(
     "--max_rows",

src/aspire/downloader/data_fetcher.py

@@ -305,8 +305,8 @@ def simulated_channelspin():
         data = dict(data)
 
     # Instantiate ASPIRE objects where appropriate
-    data["vols"] = Volume(data["vols"])
-    data["images"] = Image(data["images"])
+    data["vols"] = Volume(data["vols"], pixel_size=1.0)
+    data["images"] = Image(data["images"], pixel_size=1.0)
     data["rots"] = Rotation(_LegacySimulation.rots_zyx_to_legacy_aspire(data["rots"]))
 
     return data

src/aspire/image/image.py

@@ -519,32 +519,32 @@ def legacy_whiten(self, psd, delta):
 
         return Image(res)
 
-    def downsample(self, ds_res, zero_nyquist=True, centered_fft=True):
+    @staticmethod
+    def _downsample(data, ds_res, zero_nyquist=True, centered_fft=True):
         """
-        Downsample Image to a specific resolution. This method returns a new Image.
+        Downsample Image data to a specific resolution.
 
+        :param data: Numpy array of Image data, shape (n_imgs, resolution, resolution).
         :param ds_res: int - new resolution, should be <= the current resolution
             of this Image
         :param zero_nyquist: Option to keep or remove Nyquist frequency for even
             resolution (boolean). Defaults to zero_nyquist=True, removing the Nyquist frequency.
         :param centered_fft: Default of True uses `centered_fft` to
             maintain ASPIRE-Python centering conventions.
 
-        :return: The downsampled Image object.
+        :return: NumPy array of downsampled Image data.
         """
 
-        original_stack_shape = self.stack_shape
-        im = self.stack_reshape(-1)
-
         # Note image data is intentionally migrated via `xp.asarray`
         # because all of the subsequent calls until `asnumpy` are GPU
         # when xp and fft in `cupy` mode.
+        resolution = data.shape[-1]
 
         if centered_fft:
             # compute FT with centered 0-frequency
-            fx = fft.centered_fft2(xp.asarray(im._data))
+            fx = fft.centered_fft2(xp.asarray(data))
         else:
-            fx = fft.fftshift(fft.fft2(xp.asarray(im._data)))
+            fx = fft.fftshift(fft.fft2(xp.asarray(data)))
 
         # crop 2D Fourier transform for each image
         crop_fx = crop_pad_2d(fx, ds_res)
@@ -565,14 +565,35 @@ def downsample(self, ds_res, zero_nyquist=True, centered_fft=True):
         # At time of writing CuPy is consistent with Numpy1.
         # The additional parenths yield consistent out.dtype.
         # See #1298 for relevant debugger output.
-        out = xp.asnumpy(out.real * (ds_res**2 / self.resolution**2))
+        out = xp.asnumpy(out.real * (ds_res**2 / resolution**2))
+
+        return out
+
+    def downsample(self, ds_res, zero_nyquist=True, centered_fft=True):
+        """
+        Downsample Image to a specific resolution. This method returns a new Image.
+
+        :param ds_res: int - new resolution, should be <= the current resolution
+            of this Image
+        :param zero_nyquist: Option to keep or remove Nyquist frequency for even
+            resolution (boolean). Defaults to zero_nyquist=True, removing the Nyquist frequency.
+        :param centered_fft: Default of True uses `centered_fft` to
+            maintain ASPIRE-Python centering conventions.
+        :return: The downsampled Image object.
+        """
+        original_stack_shape = self.stack_shape
+        data = self.stack_reshape(-1).asnumpy()
+
+        ims_ds = self._downsample(
+            data, ds_res, zero_nyquist=zero_nyquist, centered_fft=centered_fft
+        )
 
         # Optionally scale pixel size
         ds_pixel_size = self.pixel_size
         if ds_pixel_size is not None:
             ds_pixel_size *= self.resolution / ds_res
 
-        return self.__class__(out, pixel_size=ds_pixel_size).stack_reshape(
+        return self.__class__(ims_ds, pixel_size=ds_pixel_size).stack_reshape(
             original_stack_shape
         )
 

src/aspire/image/xform.py

@@ -217,12 +217,21 @@ def __init__(self, resolution, zero_nyquist=True, centered_fft=True):
         super().__init__()
 
     def _forward(self, im, indices):
-        return im.downsample(
+        original_stack_shape = im.stack_shape
+        data = im.stack_reshape(-1)._data
+        im_ds = Image._downsample(
+            data,
             self.resolution,
             zero_nyquist=self.zero_nyquist,
             centered_fft=self.centered_fft,
         )
 
+        # pixel_size has already been adjusted in the ImageSource and passed
+        # to `im`, so we instantiate the new Image with im.pixel_size.
+        return Image(im_ds, pixel_size=im.pixel_size).stack_reshape(
+            original_stack_shape
+        )
+
     def _adjoint(self, im, indices):
         # TODO: Implement up-sampling with zero-padding
         raise NotImplementedError("Adjoint of downsampling not implemented yet.")

src/aspire/source/coordinates.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import warnings
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Iterable
@@ -13,7 +12,7 @@
 from aspire.operators import CTFFilter, IdentityFilter
 from aspire.source.image import ImageSource
 from aspire.storage import StarFile
-from aspire.utils import RelionStarFile
+from aspire.utils import RelionStarFile, check_pixel_size
 
 logger = logging.getLogger(__name__)
 
@@ -48,17 +47,21 @@ class CoordinateSource(ImageSource, ABC):
     """
 
     def __init__(
-        self, files, particle_size, max_rows, B, symmetry_group, pixel_size=None
+        self,
+        files,
+        pixel_size,
+        particle_size,
+        max_rows,
+        B,
+        symmetry_group,
     ):
         """
         :param files: A list of tuples of the form (path_to_mrc, path_to_coord)
+        :param pixel_size: Pixel size of the images in angstroms (Required)
         :param particle_size: Desired size of cropped particles (will override the size specified in coordinate file)
         :param max_rows: Maximum number of particles to read. (If `None`, will attempt to load all particles)
         :param B: CTF envelope decay factor
         :param symmetry_group: A `SymmetryGroup` object or string corresponding to the symmetry of the molecule.
-        :param pixel_size: Pixel size of the images in angstroms.
-            Default `None` will attempt to infer `pixel_size` from
-            `CTFFilter` objects when available.
         """
         mrc_paths, coord_paths = [f[0] for f in files], [f[1] for f in files]
         # the particle_size parameter is the *user-specified* argument
@@ -405,32 +408,10 @@ def _extract_ctf(self, data_block):
         # convert defocus_ang from degrees to radians
         filter_params[:, 3] *= np.pi / 180.0
 
-        # Check pixel_size
-        # Get pixel_sizes from CTFFilters
+        # Warn if CTF pixel_sizes do match self.pixel_size
         ctf_pixel_sizes = np.unique(filter_params[:, 6])
-        # Compare with source.pixel_size if assigned
-        if (self.pixel_size is not None) and (
-            not np.allclose(ctf_pixel_sizes, self.pixel_size)
-        ):
-            warnings.warn(
-                "Pixel size mismatch."
-                f"\n\tSource: {self.pixel_size}"
-                f"\n\tCTFs: {ctf_pixel_sizes}.",
-                stacklevel=2,
-            )
-        # When source is not assigned we can try to assign it from CTF,
-        elif self.pixel_size is None:
-            # but only do this if all the CTFFilter pixel_sizes are consistent
-            if len(ctf_pixel_sizes) == 1:
-                self.pixel_size = ctf_pixel_sizes[0]  # take the unique single element
-                logger.info(
-                    f"Assigning source pixel_size={self.pixel_size} from CTFFilters."
-                )
-            # otherwise let the user know
-            elif len(ctf_pixel_sizes) > 1:
-                logger.warning(
-                    "Unable to assign source pixel_size from CTFFilters, multiple pixel_sizes found."
-                )
+        check_pixel_size(ctf_pixel_sizes, self.pixel_size)
+
         # construct filters
         self.unique_filters = [
             CTFFilter(
@@ -557,31 +538,29 @@ class BoxesCoordinateSource(CoordinateSource):
     def __init__(
         self,
         files,
+        pixel_size,
         particle_size=None,
         max_rows=None,
         B=0,
         symmetry_group=None,
-        pixel_size=None,
     ):
         """
         :param files: A list of tuples of the form (path_to_mrc, path_to_coord)
+        :param pixel_size: Pixel size of the images in angstroms (Required)
         :param particle_size: Desired size of cropped particles (will override the size specified in coordinate file)
         :param max_rows: Maximum number of particles to read. (If `None`, will attempt to load all particles)
         :param B: CTF envelope decay factor
         :param symmetry_group: A `SymmetryGroup` object or string corresponding to the symmetry of the molecule.
-        :param pixel_size: Pixel size of the images in angstroms.
-            Default `None` will attempt to infer `pixel_size` from
-            `CTFFilter` objects when available.
         """
         # instantiate super
         CoordinateSource.__init__(
             self,
             files,
+            pixel_size,
             particle_size,
             max_rows,
             B,
             symmetry_group,
-            pixel_size=pixel_size,
         )
 
     def _extract_box_size(self, box_file):
@@ -688,32 +667,30 @@ class CentersCoordinateSource(CoordinateSource):
     def __init__(
         self,
         files,
+        pixel_size,
         particle_size,
         max_rows=None,
         B=0,
         symmetry_group=None,
-        pixel_size=None,
     ):
         """
         :param files: A list of tuples of the form (path_to_mrc, path_to_coord)
+        :param pixel_size: Pixel size of the images in angstroms (Required).
         :param particle_size: Desired size of cropped particles (mandatory)
         :param max_rows: Maximum number of particles to read. (If `None`, will
         attempt to load all particles)
         :param B: CTF envelope decay factor
         :param symmetry_group: A `SymmetryGroup` object or string corresponding to the symmetry of the molecule.
-        :param pixel_size: Pixel size of the images in angstroms.
-            Default `None` will attempt to infer `pixel_size` from
-            `CTFFilter` objects when available.
         """
         # instantiate super
         CoordinateSource.__init__(
             self,
             files,
+            pixel_size,
             particle_size,
             max_rows,
             B,
             symmetry_group,
-            pixel_size=pixel_size,
         )
 
     def _validate_centers_file(self, coord_file):